The informant was born in the United States, but her family moved from China and celebrated Chinese holidays.
After thoughts: In China and other East Asian countries, a red envelope ("hong boa") is a gift given during any special occasions. The red color of the envelope symbolizes good luck and is also a symbol to chase off evil spirits. Red envelopes are usually given out by married couples to single people regardless of age. The amount of money in the envelope usually ends with an even digit because according to Chinese beliefs, odd numbered money gifts are usually associated with funerals. The origins of the red envelope started during the Qin Dynasty, where the elderly would thread coins with a red string. The money was referred to as "money warding off evil spirits" and was also believed to protect the younger generation from sickness and death.


text:
Q: How to use set @ variable in mysql? I want set a select list as variable and do some conditional check on it:
This is my code which is not working:
set @temp = (select docId from table_1);
SELECT
   id,
   CASE when id IN (@temp) then 'TRUE' else 'FALSE' end as visited
FROM table_2;

Also tried this:
set @temp = (select docId from table_1);
SELECT
   id,
   CASE when (FIND_IN_SET(id,@temp)=1) then 'TRUE' else 'FALSE' end as visited
FROM table_2;

In both case, visited column is coming FALSE for each row.

A: You can use LEFT JOIN with GROUP BY instead. Left joining may result in duplicate rows corresponding to table_2 (as there can be multiple rows for same id value in the table_1); to handle that, we will use Group By. Count() function can be used to determine if id exists in the table_1 or not, and accordingly determine TRUE/FALSE.
Try the following:
SELECT
   t2.id,
   CASE WHEN t1.docId IS NOT NULL THEN 'TRUE' ELSE 'FALSE' END AS visited
FROM table_2 t2
LEFT JOIN table_1 t1 ON t1.docId = t2.id

redpajama_set_name: RedPajamaStackExchange


The Russo Turkish War of 1877-78 began on 24 April 1877. Fuelled by the Pan-Slavic movement Russia sought to 'liberate' the Balkans from Ottoman rule. The savage repression of uprisings in Bosnia and Bulgaria followed by Ottoman success in the 1876 Serbo-Turkish War, left the Turks with few international allies.
The Russian plan was to pass through 'neutral' Romania, cross the Danube upriver from the Turkish fortresses and then cross the Balkan mountains to Adrianople and on to the Turkish capital Constantinople. The Russian Army of the South consisted of four corps, supplemented in May by three more corps. No accurate records exist of Turkish forces and estimates vary from 186,000 to 250,000 men. The campaign began well for the Russians. By July four Russian corps had crossed the Danube and were pressing Nikopolis and Rushchuk. However, this early initiative was brought to a sudden halt. The Russian advance on Rushchuk was effectively resisted on the River Lom by Mehmet Ali and Osman Pasha force-marched 11,000 troops to hold Plevna. This town close to the Russian lines of communication to the Balkan passes became the key to the campaign. For 143 days outnumbered Turkish forces repeatedly resisted Russian assaults on the town before surrendering on 10 December. Unfortunately for Osman Pasha, divisions among the other Turkish commanders hindered an effective and co-ordinated relief effort.
The Russians supported by the Romanian army and Bulgarian volunteers crossed the Balkan Mountains aided by the capture of Shipka Pass by an advance guard led by Gourko. They advanced on Istanbul before a concerted effort by the great powers brokered a peace settlement.
The Russian infantry were generally armed with the outdated Krenk rifle. Guards and rifle battalions had the more modern Berdan. Infantry Divisions had two brigades of two, three battalion regiments. The paper strength of a battalion was around 1000 men. Cavalry divisions also had two brigades of two regiments. A cavalry regiment had around 750 men. The artillery had older bronze Krupp guns. For uniforms see below or at the visimperica site.
Latest addition to the collection is my new project using 28mm figures from the Outpost Miniatures range. First the Turks.
Then the Bulgarian Legion infantry.
The figures below are 15mm figures mainly from the Awesome Enterprises range plus some older Pioneer miniatures.


text:
Home / News / Videos
Meet the cars of 'Fast and Furious 8'
Joel Feder April 6, 2017 Comment Now!
You've likely seen the trailer for the eighth installment of the Fast and Furious franchise, The Fate of the Furious, and soon you'll be able to say you've seen the movie itself. Now we get to meet the cars that have roles in the movie.
The guys from Might Car Mods were invited to L.A. to Dennis McCarthy's shop to check out the cars from Furious 7, and they were invited once again to come back and check out the insane vehicles from The Fate of the Furious.
McCarthy is with California's Vehicle Effect, the company in charge of creating all the vehicles used in the Fast and Furious.
We learn that four Subaru BRZs were created for The Fate of the Furious and 75 percent of them survived the filming. McCarthy tells us that normally only about 25 percent of vehicles survive Fast and Furious filming, making the Subaru BRZ a resilient little car.
Then there's the latest iteration of Dom's Dodge Charger, and it's wicked. With all-wheel drive, an 18-inch wide tire, and really quick steering ratio, it's a sideways drift machine with 41 degrees of steering angle with CV axles.
As with Furious 7, Dom's new Charger is once again McCarthy's favorite car of the movie. What's more, he claims it to be his favorite car ever.
Let's not forget the damage these Fast and Furious movies bring. Recently we learned the entire franchise has caused approximately $523,222,275 in real-world damage.
Fate of the Furious will hit theaters nationwide on April 14.
Evergreen Fast and Furious movie cars Movies News Videos
The 2018 Ford Expedition just became a cop car
2018 Audi S4, 2018 Chevy Suburban, 2018 Subaru Outback: Car News Headlines
2018 Chevrolet Tahoe, Suburban RST are 420-hp frat-boy specials
Tesla is now the second most valuable automaker in the US
Joel Feder - Senior Producer
2024 Toyota Tacoma, 2024 BMW M3 CS: Today's Car News Today in Car News January 25, 2023

redpajama_set_name: RedPajamaCommonCrawl


text:
Facts about Opium:
The United Nations International Drug Control Program (UNDCP) estimates that slightly fewer than 5,000 tons of illicit opium was produced in 1997. Production in 1997 was lower than in 1994, but is still considerably higher than in 1990. The dramatic growth rates experienced in the 1980s and early 1990s, however, have given way to a certain degree of stabilization since the mid-1990s.
In terms of area under cultivation, UNDCP estimates that opium poppy cultivation in 1997 was just under 270,000 hectares, about the same as in 1990. Afghanistan and Myanmar were the main sources of increased cultivation/production over the last decade, with Afghanistan being the main source for the rise. Together these two countries accounted for about 80 per cent of global area under opium poppy cultivation and for 90 per cent of global illicit opium production in 1996-97.
The third largest producer is Laos where production fluctuated between 100-150 tons in the 1990s. Cultivation and production in Thailand and Pakistan have decreased drastically over the years and more recently Vietnam has shown a downward trend. With a combined 12,000 hectares of opium poppy, Colombia and Mexico are relatively minor global opium/heroin producers. Heroin produced in these countries is shipped to the North American market. Opium/heroin production has remained stable in both countries for several years, due mainly to vigorous opium poppy eradication policies.
Taking into account seizures of opium (210 tons on average in 1995-96) and the amounts used for domestic purposes, consumption in neighboring regions and losses in transport (in total some 30 per cent of production less seizures of opium) UNDCP estimates that about 3,300 tons of opium were available for production of heroin in 1997. Applying a 10:1 conversion rate, (opium to heroin) production of heroin in 1997 amounted to 330 tons. Less seizures of heroin (some 30 tons on average in 1995-96) about 300 tons of heroin are likely to have been available in the consumer markets.
Sources: UNDCP, Annual Reports Questionnaires; UNDCP estimates.


Topnotch decorators (topnotch construction )offer Top quality job for reasonable and affordable prices. Topnotch decorators are professional full-service interior- exterior house painting and renovating company dedicated to preserving the life of your family home with high quality materials and high quality work. We pride ourselves in our work ethics and our determination to ensure that we exceed above and beyond our customer expectations every time.
3	Paint garage door, floor and solid wood doors, handrails, railings and so on.
NOT JOB TOO BIG OR SAMLL.
Highly recommend these guys,fast tidy and did a fantastic job cheer!!
I have used Top Notch for plastering and painting a couple of times now. The 1st time I used them, they were quoting against other contractors. I was impressed by their professionalism and communication. The 2nd time I just went directly to them. I would recommend them to others and intend to use them again for another little project in future. Good work Vera and Tony keep it up!
Vera and the team did a very good job painting our ceiling. We're very happy with the result and already recommended their service to family and friends.
This company know how to take care of their customer in the best way possible. I had a small plastering and painting job that many other companies refused to accept based on being greedy however Tony came around and with a smile fixed my apartment, great quality best price. Thank you very much Tony. I highly recommend you to everyone.
Good job and good service. We we would recommend these guys for any job.
These guys are a ray of sunshine. Good communication, reasonable quotes and excellent work ethic with attention to detail. This is the 3rd job Tony and Vera have done for our family and we will keep their contact details to hand! Excellent paint job and project management for us. Thanks Tony and Vera for another job well done! Best wishes to you for the future.
Fantastic work and very very quick. We're repeat customers and would recommend these guys for any job.
Realy appricitaed the time and the effort put and the suggestions in choosing the paint colour. Highly proffessional and really affordable. Will highly reccomend for any other jobs.
vera-tony: Thanks a lot Taaj!!
We have used Tony & Vera for 3 jobs now, including cosmetic earthquake repairs to our home in Christchurch. We couldn't recommend them highly enough. We had an alternative quote on our last repair job of $2,500 which Tony was able to do for $380.
vera-tony: Thanks a lot brent and Jo. Best wishes for new move.
Quality work and very accommodating to our requirements. I will be using them again for future work. Thanks Vera and Tony.
Great service, nice and easy to deal with. Thank you, guys for amazing job painting our unit.
vera-tony: Thanks a lot! Anna!
vera-tony: Thanks a lot Gina and Neil!
Excellent service, prompt detailed quote and the job completed on time and to a high standard. Vera arrived when she said she would. Very obliging to deal with and we will be getting her back to finish the next part of our house restoration.
vera-tony: Thanks a lot Jeff and Nicki!
Thank you Vera and Tony for the outstanding job you did painting the inside of our house. Your communication was clear, you were reliable and efficient and did an excellent job in every way. I would have no hesitation to recomend you and if we ever need any more painting done, I will contact you again!
vera-tony: Thanks a lot Janet and Peter!
Excellent living up to the company name- Topnotch. Tony turned up exactly on time did a quality job for a very reasonable price. I will have them back in a heart beat and already recommending them to friends.
vera-tony: Thanks a lot Mike!
Thanks so much Topnotch team to help with my project .We have been very happy with the results. Highly reccommend !!!


text:
COVID-19: One man's thoughts
My grandfather remembers that he was walking home from school when he learned that the US had entered World War II. My mom listened to Neil Armstrong take a "giant leap for mankind" on the living room TV. I remember sitting in my seventh grade English class when I heard about the World Trade Center.
History's most indelible moments imprint in our minds where we were and what we were doing when they happened. With the coronavirus pandemic, we will remember where we weren't. March Madness, Broadway, South by Southwest. Church services, St. Patrick's Day parades, elementary schools and universities. Disney World, political primaries. All of them — closed, cancelled, or postponed.
I was transfixed by these headline-worthy changes last week, but now I'm experiencing a trickle-down effect of the coronavirus pandemic. It's the changes not reported in the media, the changes to my personal routine, that confirm this new reality — the postponement of two friends' weddings, a cancelled vacation, secretly planning and then secretly rescheduling a surprise baby shower.
When COVID-19 arrived in Louisville, where I live, I felt a sense of anxiety and stress that I couldn't shake. The governor held a daily press conference, closed schools throughout the state and, most recently, closed all bars and restaurants.
Mercer informed US and Canadian colleagues that we would work from home through the end of March, if not longer.
In some ways, these actions reduced the stress and anxiety that I and others felt, because they limited spread and exposure. But, the practices of quarantining and "social distancing," though necessary, create new, less tangible stressors.
It's unusual that so many people experience the same thing at the same time, and our current situation creates an opportunity to discuss mental health and strategies for increasing our mental wellbeing during this trying time.
Know what you can control.
Focus on what's within your control; let the rest go.
If you haven't already, you can learn the symptoms of COVID-19 and what to do if you get sick. Continue to stay informed with Mercer's daily updates. It will take many individual actions rooted in personal responsibility to mitigate the pandemic and to ease the pressure on healthcare workers and first responders.
If you're fortunate enough to be able to work from home, then do that with the knowledge that it will not be "the same" and it will likely be challenging, particularly if you have children whose schools have closed. But, you're not alone. Check in with others for whom this is the new reality — likely you'll be able to share some tips and tricks.
You can still connect with friends, family, colleagues, and neighbors. You can still have taco night. You can still stay up too late to watch one more episode. A lot of small and local businesses have also suggested ways you can support them during this critical time. A quarantine doesn't mean ignoring your community; it means putting your community first.
Refresh yourself, not the news.
It's a habit. We refresh the news and our feeds for more updates, and with the current pandemic, we're "rewarded" more often. But when you start to feel like you have a sense of what's happening, or you have a feeling of powerlessness, it's okay — encouraged, even — to step away.
If circumstances allow, go sit in your backyard or go for a walk, text a friend, start something new.
The coronavirus has actually increased how often I'm talking to my friends, most often through emails and texts, but also through video hangouts. As a matter of fact, some friends and I are dialing into a video hangout this week just to catch up — friends I haven't chatted with in quite a while.
From what I've seen, parents are getting creative with virtual field trips and online learning. And the talented artists of our great country are contributing by hosting online story time, presenting free operas, and facilitating virtual performances of all types. We do live in an amazing time.
Find ways to move around, exercise. There are guided meditation and yoga videos online, and several gyms are offering free daily workouts through their social media.
Watch that show that's been on your queue for weeks. Read a book. Write a book.
Live with empathy.
In the last six months, I started two book clubs — one with my coworkers and another with a group of friends from business school. Unintentionally, both groups recently read different books about diversity, inclusion, and privilege.
With those conversations fresh in my mind, it's impossible not to think about how even though we're all affected by this pandemic, we're not all affected in the same ways. Not everyone can work from home and not everyone has paid leave. The service and travel industries are experiencing exceptional volatility that some others may not be experiencing.
When you feel frustrated with the circumstances and the quarantine, try to remember this is a gut punch to everyone. When you're at the grocery store, remember that everyone else is trying to take care of themselves and their families, too. Empathy doesn't solve every problem, but it can put things in perspective.
Aside from the benefits to our individual mental wellbeing, there's also a business case for empathy. In the coming weeks, Mercer will release its fifth annual Global Talent Trends Study. The 2020 report draws on conversations with more than 7,000 C-suite executives, leaders, and employees in 34 countries. The report addresses some of the most significant issues to the future of work, including AI and automation, diversity and longevity, and HR transformation.
Given our shared circumstances, this year's report, which was completed earlier this year, is prescient in its findings — companies that use empathy to make decisions fare better than their peers on many key metrics.
In the coming weeks and months, life may become more constrained than it is now. There will probably be new restrictions, and they may last longer than we anticipate. Your daily life will feel smaller. In those moments, it's important to take a breath and remember this won't last forever. It's important to text a friend, message a colleague, or call someone. It's important to remember where we are — apart, but not alone.
JD Mitchell is a Global Account Manager at Mercer, where he collaborates with the compensation and benefits teams of multinational organizations. He joined Mercer in 2015.


text:
Android Mvc framework helps Android developers implement Android projects simpler and cleaner with MVC/MVP/MVVM patterns and make them testable.

## Features
  - [Easy to implement MVC/MVP/MVVM pattern](#-Implement-MVC/MVP/MVVM-pattern) for Android development
  - [Enhanced Android life cycles](#Life-cycles) - e.g. when view needs to refresh when being brought back to foreground but not on rotation, onResume() is not specific to differentiate the two scenarios. Android mvc framework provides more granular life cycles
  - [All fragment life cycles are mapped into FragmentController](#FragmentController-Life-cycles) thus more business logic can be moved into controllers including the ones in life cycles. Apps are more testable on JVM!
  - [Easy and clean navigation](#Navigation). Navigation is done in controllers instead of views. Thus navigation can be unit tested on JVM
  - [Run async tasks in controllers](#Run-AsyncTask-in-controller) and easy mocking of http requests
  - [Easy unit test on JVM](#Easy-Unit-Test) since controllers don't depend on any Android APIs
  - [Built in Event Bus](#Event-Bus). Event bus also automatically guarantees post event view events on the UI thread
  - [Automatically save and restore instance state](#Instance-State-Management). You don't have to touch onSaveInstance and onCreate(savedInstanceState) with countless key-value pairs, it's all managed by the framework.
  - [Built in simple dependency injection](#Dependency-injection-(Poke))
  - Well tested - non-Android components are tested as the test coverage status [![Coverage Status](https://coveralls.io/repos/kejunxia/AndroidMvc/badge.svg)](https://coveralls.io/r/kejunxia/AndroidMvc). For Android dependent module "android-mvc", it's tested by real emulator with [this UI test module](https://github.com/kejunxia/AndroidMvc/tree/master/library/android-mvc-test). **It's also tested with "Don't Keep Activities" turned on in dev options** to guarantee your app doesn't crash due to loss of instance state after it's killed by OS in the background!

## Implement MVC/MVP/MVVM pattern
As we know MVP and MVVM patterns are just simply derivatives of MVC pattern. All of them are targeting the same goal - Separation.

Separating Views and Controllers allows moving more business logic away from views into controllers. This makes code cleaner and, more importantly, it makes code more testable since most logical components are not depending on specific views. In the sense of Android, it means more fuctions can be written without depending on Android API therefore not have to be tested on emulators.

Since MVC, MVP and MVVM are similar, in this framework we call both **Prestener** in MVP and **ViewModel** in MVVM just as traditionally **Controller**.

- **Controller**: A controller is a delegate for business logic of a view. Thus controllers and views have **one-to-one** relationship. A controller provides methods to be invoked by the view to receive user's interactions such as click and long press. Once user's input is processed in controller, the state of view would be changed. And the controller needs to notify the view the change. When the controller needs to update view, it can be done differently in MVP and MVVM pattern
  - In **MVP**: controller calls the method view.update() of the view it holds to update the entire view. If the needed, the view can define more granular methods to update just a part of the entire view. For example, view.showProgressBar() or view.hideProgressBar().
  - In **MVVM**: controller post an event to view. View uses methods onEvent([EventClassType] event) to mointore the posted event. In the mothods the view update the UI accordingly.

- **View**: A view is an Android component that can be either Fragments, Services, Notification, Activity and etc. Every view has a controller to manage its business logic. As metioned, controllers and views have **one-to-one** relationship. Views should not process business logic but delegate all business processes to their corespondingcontrollers.
  - Note that, AndroidMvc is use a single Activity to host multiple fragments. Navgation is at fragment level and in the same activity.
- **Model**: A model represents the state of view and managed by controller. It can be accessed by controller.getModel(). The model should be reflected to Android UI in views and modified by controllers. **The model will be automatically searialized and restored in onSaveInstanceState by the framework**. So you don't need to use messy key-value pairs to save and restore view state.
- **Managers**: Managers are not necessary in MVC/MVP/MVVM model. However as metioned above, views and controllers are one-to-one mapped, when multiple views as well as their controllers share same data or logic managers are a good fit. Shared logic and data of controllers can be broken out into a manager. For example, managing logged in user is common feature of a lot apps. To have a UserManager is a perfect solution that can modify and read current users. The the manager can be used by LoginController and other controllers after login screen.
- **Services**: We are not taling about [Android Services](https://developer.android.com/guide/components/services.html). Services here are providing a layer between controller controllers and external data such as http apis, database, files, sharedPreferences and etc. Services can be injected into controllers as well as managers since managers can be thought as partial controllers.
  Services abstract out data access logic so that they can be replaced by different implementations. e.g. Use database to replace sharedPreference when the data structure become complex and query is required. In addition, the controllers can use mocked data provided by mocked services for **unit tests**.

See the diagram illustrating the relation between components above

![AndroidMvc Layers](http://i.imgur.com/dfW8TLM.png)

#### Sample code to implement MVP
- This sample shosw how a simple view just simply binds the model to the view
    ```java
    //Base view interface defined in AndroidMvc framework
    public interface UiView {
    	void update();
    }

    //Base controller defined in AndroidMvc framework
    public abstract class Controller<MODEL, VIEW extends UiView> extends Bean<MODEL> {
    	protected VIEW view;
        ....
    }

    //A concrete controller extending Controller
    public class SomeController extends Controller<SomeController.Model, UiView> {
        @Override
        public Class modelType() {
            return SomeController.class;
        }

    	//The model of the controller that represents the state of the view
        public static class Model {
            String title;
            public String getTitle() {
                return title;
            }
        }

        public void updateTitle(String text) {
            //Model is updated
            getModel().title = text;
            //Notify the view. The implementation of method update() in
            //concrete view, the view reads the model of the controller
            //and reflect the model to UI
            view.update();
        }
    }

    //View paired with the controller
    public class SomeView implements UiView {
        private TextView title;

        @Inject
        private SomeController someController;

        @Override
        public void update() {
        	//Read the controller's model and bind it to text
            title.setText(someController.getModel().getTitle());
        }
    }
    ```
- This sample shosw how a more complicated view defines extract methods to update view partially. However, this can also be done only with binding model appoach. For example, define a flag in the model, when the flag changes the controller call view.update() which show loading UI according to the flag.
    ```java
    //Extend UiView to define granular methods to update view partially instead of binding
    //entire model to the view
    public interface AsyncView extends UiView {
        void showLoadingStatus();
        void hideLoadingStatus();
    }

    //A screen view that extends MvcFragment
    public static class LoginScreen extends MvcFragment<LoginController> implements AsyncView{
        private EditText username;
        private EditText password;
        private Button button;

        //Specify the class type of the paired controller
        @Override
        protected Class<LoginController> getControllerClass() {
            return LoginController.class;
        }

        @Override
        protected int getLayoutResId() {
            return R.id.screen_login;
        }

        //Called when the view is ready. Similar to onViewCreated but this
        //callback guaranteed all injectable instances depended by this view are ready
        @Override
        public void onViewReady(View view, Bundle savedInstanceState, Reason reason) {
            super.onViewReady(view, savedInstanceState, reason);

            //assign view by findViewById
            //...
            button.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    controller.login(username.getText().toString(),
                            password.getText().toString());
                }
            });
        }

        @Override
        public void showLoadingStatus() {
            //Show progress dialog or progress bar
        }

        @Override
        public void hideLoadingStatus() {
            //Hide progress dialog or progress bar
        }

        @Override
        public void update() {
            //Bind model here
        }

    }

    public class LoginController extends FragmentController<Void, AsyncView> {
        @Override
        public Class<Void> modelType() {
            return null;
        }

        public void login(String username, String password) {
            runTask(new Task<Void>() {
                @Override
                public Void execute(Monitor<Void> monitor) throws Exception {
                    //Task.execute methods runs on non-UI thread, so we need to
                    //post the view update logic back to UI thread
                    uiThreadRunner.post(new Runnable() {
                        @Override
                        public void run() {
                            view.showLoadingStatus();
                        }
                    });

                    //Send a http request to login
                    //...
                    //Request returns successfully

                    //Task.execute methods runs on non-UI thread, so we need to
                    //post the view update logic back to UI thread
                    uiThreadRunner.post(new Runnable() {
                        @Override
                        public void run() {
                            view.hideLoadingStatus();
                        }
                    });
                    return null;
                }
            }, new Task.Callback<Void>() {
                @Override
                public void onException(Exception e) throws Exception {
                    //Call back is guaranteed to run on UI thread by the framework
                    //No need to use uiThreadRunner to post action
                    view.hideLoadingStatus();
                }
            });
        }
    }
    ```
#### Sample code to implement MVVM
    ```java
    //A concrete controller as a ViewModel
        public static class SomeController extends Controller<SomeController.Model, UiView> {
            interface Event {
                class OnModelUpdated {
                }

                class OnTitleChanged {
                    private final String title;

                    public OnTitleChanged(String title) {
                        this.title = title;
                    }

                    public String getTitle() {
                        return title;
                    }
                }
            }

            @Override
            public Class modelType() {
                return SomeController.class;
            }

            //The model of the controller that represents the state of the view
            public class Model {
                private String title;

                //Update model properties will fire events
                public void setTitle(String title) {
                    this.title = title;

                    //Post an event
                    //Note postEvent method guarantees the event will be posted to UI thread!!!
                    postEvent(new Event.OnTitleChanged(getModel().getTitle()));
                }

                public String getTitle() {
                    return title;
                }
            }

            //Expose to view to update title
            public void updateTitle(String text) {
                //Model is updated
                getModel().setTitle(text);
            }

            public void rebindModel() {
                //...
                //code to update model
                //

                postEvent(new Event.OnModelUpdated());
            }
        }

        //View paired with the controller
        public class SomeView extends View {
            private TextView title;

            @Inject
            private SomeController controller;

            @Inject
            @EventBusV //Event bus for subscribers as views
            private EventBus eventBus;

            public SomeView(Context context) {
                super(context);

                //Register this view to the event bus for views
                //Since here, when an even in type of SomeController.Event.OnTitleChanged
                //is posted, method onEvent(SomeController.Event.OnTitleChanged event)
                //will be called
                eventBus.register(this);
            }

            @Override
            protected void onAttachedToWindow() {
                super.onAttachedToWindow();

                //Unregister the view from the event bus.
                //This is working but not ideal because the event bus will be unregistered until
                //the view is removed from the window not it's parent
                //You can consider viewGroup.setOnHierarchyChangeListener

                //but make sub view in fragments extending MvcFragment is recommended since
                //MvcFragment register and unregister event bus in onCreate and onDestroy
                //lifecycle call backs.
                //
                //This is just an example of using eventBus manually.
                eventBus.unregister(this);
            }

            //Monitor event SomeController.Event.OnTitleChanged
            //All event subscriber methods should be called onEvent with one argument of the
            //event's class type
            private void onEvent(SomeController.Event.OnTitleChanged event) {
                title.setText(event.getTitle());
            }

            //Monitor event SomeController.Event.OnModelUpdated
            private void onEvent(SomeController.Event.OnModelUpdated event) {
                title.setText(controller.getModel().getTitle());

                //other views to bind to the controller/ViewModel's model
                //...
            }
        }
    ```

## Fragment Life cycles
Since AndroidMvc framwork is designed to implement apps with a single Activity in most cases. Fragments are playing an important role. In the framework, fragments can be used as a screen which is the what an activity does traditionally. Also it can be used as sub view as well.

Below are life cycle callback of MvcFragment provided by AndroidMvc framework
- **onCreateView** is final and **SEALED**, use onViewReady described below
- **onViewCreated** is final and **SEALED**, use onViewReady described below
- **onViewReady**(View, Bundle, **Reason**) is called when the fragement is ready to bind Android widgets by findViewById and **use controllers**. The argument "Reason" indicates why the view is created or recreated. For example, view is created
  - first time
  - on restoration
  - rotation.
- **onReturnForeground** called when the app is brought to the front after being pushed to background. It complements onResume since onResume doesn't differentiate foregrounding app, rotation, creation and etc.
- **onPushToBackStack** called when the fragment is about to be pushed to back stack typically on navigation. It complements onPause since onPause doesn't differentiate pushing to back stack, removing fragment, rotation and etc.
- **onPoppedOutToFront** called when the fragment is popping out from the fragment backstack to present as the top most fragment.
- **onPopAway** called when the fragment was the top most presenting fragment but will be popped away and replaced by the fragment will pop out under it.
- **onPreNavigationTransaction(FragmentTransaction transaction, MvcFragment nextFragment)** called before the fragment transaction is about to commit that will replace current fragment by the next. It's main providing the transaction being committed to configure transaction animation. e.g adding SharedElements
- **onOrientationChanged** called when orientation changed.

## FragmentController Life cycles
All fragment life cycles are mapped into [FragmentController](https://github.com/kejunxia/AndroidMvc/blob/master/library/android-mvc-core/src/main/java/com/shipdream/lib/android/mvc/FragmentController.java). So fragments are further liberated from handling business logic. For example, if you need to do some stuff in Framgent.onViewReady, you can do it in FragmentController.onViewReady.

Here are the life cycles
- **onCreate** when the controller is injected into the corresponding fragment
- **onViewReady(Reason)** is called when the fragement is ready to show. The argument "Reason" indicates why the view is created or recreated. For example, view is created
  - first time
  - on restoration
  - rotation.
- **onResume** callced when the fragment is calling its own onResume
- **onPasue** called when the fragment is calling its own onPuase
- **onDestroy** called when the controller is released from being used by the corresponding fragment and not referenced by anything it was injected to.
- **onBackButtonPressed()** called when the phycical back button is pressed
- **onReturnForeground** samed as the corresponding life cycle callback in fragment
- **onPushToBackStack** samed as the corresponding life cycle callback in fragment
- **onPoppedOutToFront** samed as the corresponding life cycle callback in fragment
- **onPopAway** samed as the corresponding life cycle callback in fragment
- **onOrientationChanged** called when orientation changed.

## Navigation
As metioned earlier, AndroidMvc framework uses single activity to create Android apps. Therefore navigation in AndroidMvc is to swap full screen fragments. Though fragment transactions involve complexity primarily because they may be committed asynchronously, AndroidMvc aims to wrap all the tricks up. This is another reason why onCreateView and onViewCreated life cycle call back are sealed and replaced by onViewReady() metioned in [FragmentController Life cycles](#FragmentController-Life-cycles) section.

The navigation functions are tested in instrumentation test cases. If you are interested you can check out the in [instrumentation test project](https://github.com/kejunxia/AndroidMvc/tree/master/library/android-mvc-test).

#### Mapping between [MvcFragment](https://github.com/kejunxia/AndroidMvc/blob/master/library/android-mvc/src/main/java/com/shipdream/lib/android/mvc/MvcFragment.java) and [FragmentController](https://github.com/kejunxia/AndroidMvc/blob/master/library/android-mvc-core/src/main/java/com/shipdream/lib/android/mvc/FragmentController.java)

- [MvcFragment](https://github.com/kejunxia/AndroidMvc/blob/master/library/android-mvc/src/main/java/com/shipdream/lib/android/mvc/MvcFragment.java) should be extended by fragments in AndroidMvc. It can represents a screen or just a sub view.
  - It can represent a full screen
  - It also can be used for just a sub view
  - Class extending [MvcFragment](https://github.com/kejunxia/AndroidMvc/blob/master/library/android-mvc/src/main/java/com/shipdream/lib/android/mvc/MvcFragment.java) needs to abstract method **MvcFragment#getResouceId()** to provide the layout resouce id that will be automatically inflated as the root view of the fragment.
  - Class extending [MvcFragment](https://github.com/kejunxia/AndroidMvc/blob/master/library/android-mvc/src/main/java/com/shipdream/lib/android/mvc/MvcFragment.java) needs to implement the abstract method **MvcFragment#getControllerClass()** to provide the class type of a concrete [FragmentController](https://github.com/kejunxia/AndroidMvc/blob/master/library/android-mvc-core/src/main/java/com/shipdream/lib/android/mvc/FragmentController.java). The MvcFragment will automatically create inject the instance of the controller. You don't need to create it, just use MvcFragment.controller straight away.
    - Note that, null is allow to returned if the fragment doesn't need a controller or you want to inject your own controller by @Inject manually for a reason. However, beware of that in this case MvcFragment.controller will be **NULL**.
- [FragmentController](https://github.com/kejunxia/AndroidMvc/blob/master/library/android-mvc-core/src/main/java/com/shipdream/lib/android/mvc/FragmentController.java) should be extended by a concrete controller for a [MvcFragment](https://github.com/kejunxia/AndroidMvc/blob/master/library/android-mvc/src/main/java/com/shipdream/lib/android/mvc/MvcFragment.java).
  - It can be used by [NavigationManager](https://github.com/kejunxia/AndroidMvc/blob/master/library/android-mvc-core/src/main/java/com/shipdream/lib/android/mvc/NavigationManager.java) to navigate to its corresponding MvcFragment. In this case, the corresponding MvcFragment will be treated as a full screen page. See the code snippet in [sample code](https://github.com/kejunxia/AndroidMvc/blob/master/samples/simple-mvp/core/src/main/java/com/shipdream/lib/android/mvc/samples/simple/mvp/controller/CounterMasterController.java) as below
    ```java
    public void goToDetailScreen(Object sender) {
        navigationManager.navigate(sender).to(CounterDetailController.class);
    }
    ```

#### Routing
Routing rules can be defined in you main activity extending [MvcActivity](https://github.com/kejunxia/AndroidMvc/blob/master/library/android-mvc/src/main/java/com/shipdream/lib/android/mvc/MvcActivity.java). Implement method **MvcActivity#mapControllerFragment()** to map which fragment will be launched as a full screen page for the corresponding controller class type.

A typical routing rule is as the code below.
```java
@Override
protected Class<? extends MvcFragment> mapFragmentRouting(
        Class<? extends Controller> controllerClass) {
    if (controllerClass == CounterMasterController.class) {
        return CounterMasterScreen.class;
    } else if (controllerClass == CounterDetailController.class) {
        return CounterDetailScreen.class;
    } else {
        return null;
    }
}
```

If you want more automation, you can choose your own package structure file name pattern to apply a generic routing rule to locate concrete MvcFragment classes like below. See the code in the [sample project](https://github.com/kejunxia/AndroidMvc/blob/master/samples/simple-mvp/app/src/main/java/com/shipdream/lib/android/mvc/samples/simple/mvp/MainActivity.java)
```java
@Override
protected Class<? extends MvcFragment> mapFragmentRouting(
        Class<? extends FragmentController> controllerClass) {
    String controllerPackage = controllerClass.getPackage().getName();

    //Find the classes of fragment under package .view and named in form of xxxScreen
    //For example

    //a.b.c.CounterMasterController -> a.b.c.view.CounterMasterScreen

    String viewPkgName = controllerPackage.substring(0, controllerPackage.lastIndexOf(".")) + ".view";
    String fragmentClassName = viewPkgName + "."
            + controllerClass.getSimpleName().replace("Controller", "Screen");

    try {
        return (Class<? extends MvcFragment>) Class.forName(fragmentClassName);
    } catch (ClassNotFoundException e) {
        String msg = String.format("Fragment class(%s) for controller(%s) can not be found",
                fragmentClassName, controllerClass.getName());
        throw new RuntimeException(msg, e);
    }
}
```

#### Continuity between screens
AndroidMvc has 3 different ways to ensure continuity between two consequent screens on navigation transition

1. Shared injectable instances will be retained through the navigation transition. For example, when 2 controllers have the same type of manager injected the same instance of the manager from the first screen's controller will be retained for the second screen's controller. You can check out the [sample code](https://github.com/kejunxia/AndroidMvc/tree/master/samples/simple-mvp), in the [CounterMasterController](https://github.com/kejunxia/AndroidMvc/blob/master/samples/simple-mvp/core/src/main/java/com/shipdream/lib/android/mvc/samples/simple/mvp/controller/CounterMasterController.java) there is an injected field called counterManager which is injected into [CounterDetailController](https://github.com/kejunxia/AndroidMvc/blob/master/samples/simple-mvp/core/src/main/java/com/shipdream/lib/android/mvc/samples/simple/mvp/controller/CounterDetailController.java) as well. So when master controller navigate to detail controller, the state of the manager retains.
2. Just prepare the controller of the next screen just before navigation is taking place. In this case, the controller prepared will be injected into the next screen framgment.

    ```java
    navigationManager.navigate(this).with(CounterDetailController.class,
                new Preparer<CounterDetailController>() {
            @Override
            public void prepare(CounterDetailController detailController) {
                //Set the initial state for the controller of the next screen
                detailController.setCount(123);
            }
        }).to(CounterDetailController.class);
    ```
3. Hold an injected instance of the manager depending on the next screen in the controller held by the delegateFragment. DelegateFragment is a long life fragment in the single activity containing all other fragments, so its controller will referenced during the entire lifespan of the app UI comopnent. So the inject managers held by the controller remain during the whole app session. For example, AndroidMvc has already had an internal controller for the delegateFragment holding NavigationManager, so the navigationManager is singleton globally and live through the entire app life span. Another example is, you can have an AccountManager held by delegateFragment's controller so accountManager will span the entire app session to manage the logged in user.

#### Navigation tool bar
The screen fragment doesn't have to take the entire screen. For example, all screens can share the same toolbar just like the tranditional ActionBar.

More details can be found in the [Sample Code](https://github.com/kejunxia/AndroidMvc/tree/master/samples/simple-mvp)

## Run AsyncTask in controller
When a http request need to be sent or other long running actions need to be performed, they need to be run off the UI thread. To run an asyncTask in controllers, simply call
```java
//In any controller method you can use below code to run async task

Task.Monitor<Void> monitor = runTask(new Task<Void>() {
    @Override
    public Void execute(Monitor<Void> monitor) throws Exception {
        //Execute on Non-UI thread
        //When the view need to be updated here, you need use
        //uiThreadRunner to post it back to UI thread

        return null;
    }
}, new Task.Callback<Void>() {
    @Override
    public void onException(Exception e) throws Exception {
        //Handle exception
        //All callback methods are executed on UI thread
    }
});

//If you need to cancel unscheduled or executing task, call
//cancel against its monitor
boolean canInterrupt = true;
monitor.cancel(canInterrupt);
```

As you see, runTask will give you a monitor which can be used to query the state of the task or cancel it if it has not started or interupt the currently executing task for example a downloading task.

**Tips**:
- Only run async task in controllers to avoid blocking UI thread. All methods in managers or services should simply be synchrounous. Since managers and services are supposed to be consumed by controllers, when they are in use, controllers can choose invoke methods of managers and services on non-UI thread or not.
- In the scope the Task.execute() every line is running in sequence. The callback.onScucess will be called until all lines in Task.execute() execute successfully otherwise, callback.onException is called.
- You can run multiple long running methods in the same Task.execute() method. It's useful if you need to send some consequent http requests each is depending the previous response. So any one of the requests fails, it fails the entire task. See example:
    ```java
    Task.Monitor<Void> monitor = runTask(new Task<Void>() {
        @Override
        public Void execute(Monitor<Void> monitor) throws Exception {
            //Send login http request
            Login loginResponse = loginHttpService.login(username, password);

            //use the token contained in loginResponse to send another http
            //request to register device to push notification services
            Status status = pushNotificationHttpService.register(deviceId, loginResponse.token());
            return null;
        }
    });
    ```

## Easy Unit Test
So far, you should have already got some ideas how much business logic can be written in controllers with AndroidMvc. [See sample unit tests here](https://github.com/kejunxia/AndroidMvc/tree/master/samples/simple-mvp/core/src/test/java/com/shipdream/lib/android/mvc/samples/simple/mvp/controller/internal)

#### Mock dependencies
As most codes are wrapped in controllers without Android API dependencies. You can just simply test everything on JVM. Because in app, there are dependencies implemented with Android API which are lacking in the sole controller module, those dependencies' implementations need to be replaced by mocked instances. For example, every controller has an injected field - ExecutorService to run a aysncTask by
controller.runTask(Task task). In unit test, this ExecutorService can be mocked and run task immediately on the same thread to mimic a http response with mocked data.

To override providers to replace injectable classes,
1. create a MvcComponent say overridingComponent
2. register your providers to provider mocking objects
3. attach the overridingComponent to Mvc.graph().getRootComponent() with the

See the code sample below
```java
//Mock executor service so that all async tasks run on non-UI thread in app will
//run on the testing thread (main thread for testing) to avoid multithreading headache
executorService = mock(ExecutorService.class);

doAnswer(new Answer() {
    @Override
    public Object answer(InvocationOnMock invocation) throws Throwable {
        Callable runnable = (Callable) invocation.getArguments()[0];
        runnable.call();
        Future future = mock(Future.class);
        when(future.isDone()).thenReturn(true); //by default execute immediately succeed.
        when(future.isCancelled()).thenReturn(false);
        return future;
    }
}).when(executorService).submit(any(Callable.class));

overridingComponent = new MvcComponent("TestOverridingComponent");
overridingComponent.register(new Object(){
    @Provides
    public ExecutorService createExecutorService() {
        return executorService;
    }
});

//For base test class, allow sub test cases to register overriding providers
prepareGraph(overridingComponent);

Component rootComponent = Mvc.graph().getRootComponent();

//overriding indicates providers of this component attached to the root component will override
//existing providers managing to provide instances with the same type and qualifier.
boolean overriding = true;
rootComponent.attach(overridingComponent, overriding);
```

#### Mock http response
Below are some code snippets of mocking http traffic. More code can be found in the  [sample](https://github.com/kejunxia/AndroidMvc/tree/master/samples/simple-mvp) in the project. The sample is using Retrofit for http resources.

- **Mock Successful http response**

    ```java
    @Test
    public void should_update_view_with_correct_ip_and_show_and_dismiss_progress_bar() throws Exception {
        //Prepare
        //Prepare a good http response
        final String fakeIpResult = "abc.123.456.xyz";

        IpPayload payload = mock(IpPayload.class);
        when(payload.getIp()).thenReturn(fakeIpResult);
        when(ipServiceCallMock.execute()).thenReturn(Response.success(payload));

        //Action
        controller.refreshIp();

        //Verify
        //Showed loading progress
        verify(view).showProgress();
        //Dismissed loading progress
        verify(view).hideProgress();
        //Updated view's text view by the given fake ip result
        verify(view).updateIpValue(fakeIpResult);
        //Should not show error message
        verify(view, times(0)).showHttpError(anyInt(), anyString());
        //Should not show network error message
        verify(view, times(0)).showNetworkError(any(IOException.class));
    }
    ```
- **Mock erred http response**

    ```java
    @Test
    public void should_show_error_message_on_HttpError_and_show_and_dismiss_progress_bar() throws Exception {
        //Prepare
        //Return 401 in the http response
        int errorStatusCode = 401;
        ResponseBody responseBody = mock(ResponseBody.class);
        when(ipServiceCallMock.execute()).thenReturn(
                Response.<IpPayload>error(errorStatusCode, responseBody));

        //Action
        controller.refreshIp();

        //Verify
        //Showed loading progress
        verify(view).showProgress();
        //Dismissed loading progress
        verify(view).hideProgress();
        //View's ip address text view should not be updated
        verify(view, times(0)).updateIpValue(anyString());
        //Should show http error message with given mocking data
        verify(view, times(1)).showHttpError(errorStatusCode, null);
        //Should not show network error message
        verify(view, times(0)).showNetworkError(any(IOException.class));
    }
    ```
- **Mock network error**

    ```java
    @Test
    public void should_show_error_message_on_NetworkError_and_show_and_dismiss_progress_bar() throws Exception {
        //Prepare
        //Throw an IOException to simulate an network error
        IOException ioExceptionMock = mock(IOException.class);
        when(ipServiceCallMock.execute()).thenThrow(ioExceptionMock);

        //Action
        controller.refreshIp();

        //Verify
        //Showed loading progress
        verify(view).showProgress();
        //Dismissed loading progress
        verify(view).hideProgress();
        //View's ip address text view should not be updated
        verify(view, times(0)).updateIpValue(anyString());
        //Should not show http error message
        verify(view, times(0)).showHttpError(anyInt(), anyString());
        //Should show network error message with the given mocking exception
        verify(view, times(1)).showNetworkError(ioExceptionMock);
    }
    ```

## Event Bus
There are event buses built in the framework can be used straight away.
- **Event bus object can be injected by @Inject as a field of a class.**
- **There are two event buses in the framework. Both event buses are singleton app wide.**
  - **EventBusC**: Routes events to non-view objects. Events on this bus usually come from non-Android module(see [core module in the the sample](https://github.com/kejunxia/AndroidMvc/tree/master/samples/simple-mvp)). Events on the bus will be **observed on the same thread** that the invoker is running.
  - **EventBusV**: Routes events to view/android objects such as activity, fragment, services and etc. Events on the bus will be guaranteed to be **observed on the UI thread** automatically by the framework.
- **Event buses above can be injected with qualifiers.**
    ```java
    @Inject
    @EventBusC
    private EventBus eventBusC;

    @Inject
    @EventBusV
    private EventBus eventBusV;
    ```
- **Events are defined by a class type.** It's recommended to define it as enclosed class if it's closely related to the class. As a result, the observer knows what events are for what. For example,
    ```java
    public class UserManager {
        interface Event {
            class OnUserLoggedIn{
            }
        }

        //...
        public void func() {
            eventBus.post(new Event.OnUserLoggedIn());
        }
    }
    ```
- **Events can have their own arguments.** For example,
    ```java
    class OnUserLoggedIn {
        private final User user;
        public OnUserLoggedIn(User user) {
            this.user = user;
        }
        public User getUser() {
            return user;
        }
    }
    ```
- **Sender as an argument in an event is a good practice.** To define a sender argument in an event is useful to distiguish who initiate the request results in this event. For example, when refreshing a list view, you may need different logic to handle the requests caused by
  - User interaction. e.g. pull to refresh
  - Some internal state change. e.g. a polling every 3 seconds

  In this case, define a sender argument in the event class. Then when observers receive the event they know who initially request the refresh and handle differently.
- **Events are observed by methods with naming convention.** To subscribe an event by declaring a method called **onEvent** with **one argument** in the class type of the event. The name of the event doesn't matter. For example
    ```java
    public class OneView {
        //Observe event OnListViewRefreshed.
        private void onEvent(OnListViewRefreshed event) {
            //handle event
        }
    }
    ```
- **Event bus needs to be registered to observe event** by calling EventBus.register(Object observer). However, these pre-defined Mvc objects register by themselves so you don't need to worry about to registering by using them. Just define your onEvent methods to subscribe. These objects are:
  - **MvcActivity** registers to **EventBusV** when created
  - **MvcFragment** registers to **EventBusV** when created
  - **MvcService** registers to **EventBusV** when created
  - **Controller** registers to **EventBusC** when injected for the first time
  - **Manager** registers to **EventBusC** when injected for the first time

  If you have your own objects need to observe a event bus, just call EventBus.register(Object observer) when they are created. Also it's better to unregister them when the obsever is not used any more. This can be done in onDestroy life cycle.

Below is a code snippet. Note that the code is not complete to run but just for demostrating how to use event bus
```java
public class OneView {
    @Inject
    private OneController onController;

    private Button refreshButton;

    public void onCreated() {
        eventBusV.register(this);

        refreshButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View refreshButton) {
                onController.refresh(refreshButton);
            }
        });
    }

    public void onDestroy() {
        eventBusV.unregister(this);
    }

    //Observe event OnListViewRefreshed from OneController
    //It runs on UI thread automatically
    private void onEvent(OneController.Event.OnListViewRefreshed event) {
        if (event.getSender() == refreshButton) {
            //refreshed by user interaction of pressing the refresh button
            //so if erred, it's better to show error message
        } else {
            //should by something else, e.g. controller wants to refresh for some
            //reason
            //In this case, error message may not have to be shown
        }

        //refresh the list view
    }
}

public class OneController extends Controller{
    interface Event {
        public class OnListViewRefreshed {
            private final Object sender;
            public OnListViewRefreshed(Object sender) {
                this.sender = sender;
            }

            public Object getSender() {
                return sender;
            }
        }
    }

    @Inject
    private NavigationManager navigateManager;

    @Inject
    @EventBusV
    private EventBus eventBusV; //Framework guarantees the event will be posted to UI thread

    public void refresh(final Object sender) {
        runTask(new Task() {
            @Override
            public Object execute(Monitor monitor) throws Exception {
                //Pull data from http server
                //...
                //

                //successful and post event
                //Though execute method is run on non-Ui thread,
                //eventBusV will guarantee the observer will receive the event onto
                //UI thread
                eventBusV.post(new Event.OnListViewRefreshed(sender));
                return null;
            }
        });
    }

    //Observe logged on event from UserManager
    private void onEvent(UserManager.Event.OnLoggedOut event) {
        //...
        //User logged out

        navigateManager.navigate(this).to(LoginController.class, new Forwarder().clearAll());
    }
}

public class UserManager {
    interface Event {
        class OnLoggedOut{
            private final Object sender;
            public OnLoggedOut(Object sender) {
                this.sender = sender;
            }

            public Object getSender() {
                return sender;
            }
        }
    }

    @Inject
    @EventBusC
    private EventBus eventBusC;

    public void setCurrentUser(Object sender, User user) {
        //...

        //EventBusC post event to the thread that the invoker calling setCurrentUser
        //is running on
        eventBusC.post(new Event.OnLoggedOut(sender));
    }
}
```

## Instance State Management
Instance state management in standard Android SDK is painful. It requires defining countless key-value pairs. No mention to create Paracelable needs to write a lot of boilerplate code and it's error prone.

AndroidMvc framework manages the state automatically. Since a controller represents a view in abstraction so it has a property called model to contain the state of its view. AndroidMvc just getModel() and serialise it when the app is pushed to background and deserialise the model and bind it to the controller and view automatically. This is why you just need to bind the view in UiView.update() method and then no matter the view is newly created or restored, it's always reflecting the latest state of the model managed by the view's controller. Review [Implement MVC/MVP/MVVM pattern](#-Implement-MVC/MVP/MVVM-pattern) to check the patterns.

Also not just controllers manage their state automatically, managers, services and any injected objects extending Bean(#https://github.com/kejunxia/AndroidMvc/blob/master/library/android-mvc-core/src/main/java/com/shipdream/lib/android/mvc/Bean.java) and returns non-null class type in its method modelType() will be automatically managed. See more details about Bean.java and injection in section [Dependency injection](#Dependency-injection-(Poke))

## Dependency injection (Poke)
The framework has a built in dependency injection called **Poke**.
Why reinvent the wheel?
* The main reason is to incorporate with [AndroidMvc](http://kejunxia.github.io/AndroidMvc/) framework, it needs to do **reference count**. Since [AndroidMvc](http://kejunxia.github.io/AndroidMvc/) automatically saves and restores state of controllers, when a controller is not used its state won't need to be managed any more. So [AndroidMvc](http://kejunxia.github.io/AndroidMvc/) needs to know when a controller is not referenced.
* Another reason: In Dagger, a lot of boiler plate code still needs to be done. This definitely minimizes run time overhead for injection but there are just two much codes. And you need to remember to declare you injection. It's almost like writting a setter or inject method for each injectable class and then we need to manually set or inject objects.

To find the balance between simpler code and runtime performance, **Poke** can use naming convention to automatically locate implementations. So we don't need to repeatedly declare implementations by writing in **real** application with. However, **Poke** also allows registering implementation manually. This is helpful either for dynamical replacement of implementations or mocking injectable dependencies in unit tests.

#### Bean
Classes and interfaces can be injected with the their instances. There are some classes can be injected with some special behaviours. These classes are called beans. A [Bean](https://github.com/kejunxia/AndroidMvc/blob/master/library/android-mvc-core/src/main/java/com/shipdream/lib/android/mvc/Bean.java) is an object
1. has life cycles. When a bean is created by the first injection, its method **onCreated** will be called. When a bean is released by the last object it was injected into, it method **onDestroy** will be called.
2. has a model. A model contains the state of the bean that can be serialised and deserialised. So the bean's state can be saved and restored during the Android's activity and fragment's life cycles.

In AndroidMvc framework there are a couple of pre-defined beans
- [Controllers](https://github.com/kejunxia/AndroidMvc/blob/master/library/android-mvc-core/src/main/java/com/shipdream/lib/android/mvc/Controller.java)
- [Managers](https://github.com/kejunxia/AndroidMvc/blob/master/library/android-mvc-core/src/main/java/com/shipdream/lib/android/mvc/Manager.java)
So controllers and managers(can be thought as partial controller that are shared by controllers) will have their life cycle and be automatically saved and restored. And you can define you own beans without any restrictions. Just simply make the class extend the Bean class.

If you want to use an interface as a bean, just extend bean class in its implementation.

#### Architecture
Below are the main parts to inject objects
- **Providers** provide instances. Providers can be registered to component.
- **Components** contain providers. Components can also the attached to other components to form a component tree.
  - **Scope** A component has a cache to cache instances provided by providers held by the component. So providers are **singleton** in the scope of a component. You can set the cache of a component to be null. Then the providers in this component will always create new instances.
  - By default, a component tree can only have unique provider providing instances with a specific class type and qualifier. Registering a provider to a component tree with duplicate to provide instance of type and qualifier already existing will throw exceptions.
  - But you can explicitly declare you want to register a provider overriding the existing providers with the same class type and qualifier in the component tree. Last overriding provider registered wins.

      ```java
      boolean overriding = true;
      rootComponent.attach(overridingComponent, overriding);
      ```
- **Graph** A graph is used to inject instances into target objects. A graph has a root component with providers or its child components providers to provide instances to be injected. Usually an application should have only one graph. So by default, providers registered to the root component of the graph is Singleton globally. To have different scope, simply manage your own components and attach/detach them to/from the root components of the graph. Providers of these components will be singleton until the components are detached from the graph.

#### How to inject
With poke and AndroidMvc, to inject an instance is easy. It doesn't need to declare  what needs to don't need to  Below we will explore how to inject in different scenarios.
- Inject an instance of a concrete class

  AndroidMvc automatically inject concrete classes that have an empty default constructors.

    ```java
    public class Break {
        public void slow(Car car) {
            car.setSpeed(car.getSpeed() - 1);
        }
    }
    public class Car {
        @Inject
        private Break aBreak;
        private float speed;
        public float getSpeed() {
            return speed;
        }
        public void setSpeed(float speed) {
            this.speed = speed;
        }
        public void decelerate() {
            aBreak.slow(this);
        }
    }
    @Test
    public void run_car_with_default_components() {
        Car car = new Car();
        Mvc.graph().inject(car);
        car.decelerate();
    }
    ```
- Inject an instance of an interface or abstract class

  By default, AndroidMvc will look for implementation class of interface or abstract class in the sub package **"internal"** at the same level of the package of the interface or abstract class. The implementation class should have the same name of the interface or abstract class but with a suffix **"impl"**. And the rest steps to inject an instance of an interface or an abstract class is exactly the same as injecting a concrete class as above.
  For example, when we have an interface called Engine under package com.xyz. To let AndroidMvc find its implementation automatically, the concrete class should call Engine**Impl** and resides under com.xyz.**internal***. See the file structure below
    ```
    --com
      --xyz
        Engine.java
        --internal
          EngineImpl.java
    ```
- Customise providers

  You can also register a provider to a component attached to the graph. Or register an object with methods annotated by @Provides to provide instance.
    ```java
    MvcComponent testComponent = new MvcComponent("TestComponent");

    //Register new providers with better v8 engine and racing break
    testComponent.register(new Object(){
        @Provides
        public Engine v8Engine() {
            return new Engine() {
                @Override
                public void push(Car car) {
                    car.setSpeed(car.getSpeed() + 3);
                }
            };
        }

        @Provides
        public Break racingBreak() {
            return new Break() {
                @Override
                public void slow(Car car) {
                    car.setSpeed(car.getSpeed() - 2.5f);
                }
            };
        }
    });
    ```
- Override existing providers

  Registering providers providing classes for same signature of class (same class type and qualifier) will result in throwing out exceptions since AndroidMvc won't be able to figure out which provider should be used. But the you can implicitly inform AndroidMvc you want to override providers with code like below
    ```java
    //Attach the component to the graph's root component to override default providers
    boolean overrideExistingProviders = true;
    Mvc.graph().getRootComponent().attach(testComponent, overrideExistingProviders);
    ```

redpajama_set_name: RedPajamaGithub


text:
Adventures with Waffles
Written by Maria Parr
more titles by Maria Parr
more titles by Kate Forrester
Maria Parr's bio
author: Maria Parr
illustrator: Kate Forrester
translator: Guy Puzey
Hardly a day passes without Trille and Lena inventing some kind of adventure that often ends in trouble. Whether it's coaxing a cow onto a boat or sledding down the steepest and iciest hill with a chicken, there is always a thrill—and sometimes an injury—to be had. Trille loves to share everything with Lena, even Auntie Granny's waffles. But when Lena has to move away and Auntie Granny leaves the world, it sometimes seems like nothing will ever be right again. The warmth of friendship and the support of family suffuse this lightly illustrated novel, proving that when times are tough, a little taste of sweetness can make all the difference.
Lena is Trille's best friend, even if she is a girl. And there is never an ordinary day when you've got a best friend like Lena.
$16.99 / $22.99 isbn-10/isbn-13:
Middle-grade Novel / Hardback
7 yrs - 10 yrs # of pages/size:
240 / 5" x 7"
Family; Humorous Stories; Social Issues; Religious; Sports & Recreation;
Maria Parr is a writer and high-school teacher. Adventures with Waffles, her debut novel, is available in twenty-six countries and has won several awards around the world. Maria Parr lives in Norway with her family.
Guy Puzey began translating Norwegian literature after studying the language at the University of Edinburgh and now works at the university as a researcher and teacher. He grew up in the Highlands of Scotland, just a short but cold swim away from Norway.


text:
Portland's Bike Cred Takes Another Knock
By Brian Barker 5/19/2010 at 9:00am
Well, it happened again: Our bike scene has been one-upped by a bunch of (apparently) pedal-happy Minnesotans. In their just released rankings for bike friendliness, The League of American Bicyclists revealed that Oregon is now considered just the fifth friendliest state for biking. You read that right. Fifth.
For the last two years the Beaver State has held onto the fourth spot, (behind Washington, Wisconsin, and Maine in 2009 and Washington, Wisconsin, and Arizona in 2008). But this year, Minnesota, no doubt led by Minneapolis, the same city that snatched our top ranking from Bicycling magazine just a few weeks back, grabbed the fourth spot and bumped us down to fifth. Look at me, I can't stop saying it: Fifth.
I can see all those Vikings and Golden Gophers now. They're probably laughing in their Favre jerseys (he is no. 4 after all) chanting, "Purple Portland Eaters." At this point, it wouldn't surprise me if Garrison Keillor rode out on stage on a fixie while wearing horns and waiving a big golden 5 just to taunt us during his appearance at the Oregon Zoo's concert series this summer.
And talk about bad timing. The news comes just days after Metro released its eighth Bike There! map, which plots out more than 800 miles of bike trails in 21 cities. The thing is even waterproof.
Apparently, the only thing that's missing—plans to take back our moxie from those Midwesterners.


Program manager for Point in Time Centre for Children, Youth and Parents, Dan Bajorek, presents Cardiff Elementary School's vice-principal Barb Davies with the school's very own full-sized puppet named Zach on Thursday, April 17 at Cardiff Elementary School in Cardiff.
From left, Shane Musclow, Dakota Desousa and Owen Burke, and their puppets (all named Joe) perform their show titled The Artist's Problem on Thursday, April 17 at Cardiff Elementary School in Cardiff. Their performance was part of the Haliburton Arts Council's Artists in the Schools program.
Since it began in 2004 the Haliburton Highlands Arts Council's Artists in the Schools program has been teaching children to be more imaginative and creative individuals through embracing the arts.
Participating in the program are ceramic artists, puppeteers, actors, musicians, dancers, painters, sculptors, print-markers, percussionists, jewellers, storytellers, artist blacksmiths, glass blowers, and fabric artists. Over the last five weeks chief executive puppeteer and workshop facilitator for Puppeteria, Shelley King has been sharing her creativity and expertise with students and teachers at Cardiff Elementary School (CES).
"The puppets really bring the kids out of their shells," said King.
King has not only been teaching kids how to be more socially engaged with one another through the arts, she has also been showing the children how to make their own puppets. Constructing them out of materials donated by the arts council, the kids are encouraged to give each of their puppets its own name and personality.
"The puppets allow them the chance to speak their minds more freely," said King.
The Point in Time Centre for Children, Youth and Parents has also been working with the program at CES. Point in Time offers a wide range of supports and services to children, youth and families throughout Haliburton County. These services include: family support, mental health services and youth justice. On Thursday, April 17 program manager for Point in Time, Dan Bajorek, presented the students with the school's very own full-sized puppet named Zach. Realizing how beneficial the puppets have been for the kids at CES, Point in Time donated the professional-quality puppet valued at nearly $1,000.
"We are thrilled to be able to contribute to this program," said Bajorek.
Vice-principal Barb Davies said the Artists in the Schools program improves learning opportunities for the students and the teachers. She said both the staff and the students really appreciates the skills, knowledge and techniques that the artists share with the school.
"Our local artists are so talented and professional," said Davies.
Cardiff Elememtary School students show off their new homemade puppets on Thursday, April 17 at Cardiff Elementary School in Cardiff. They created the puppets with help from puppeteer Shelley King, seen far right, as part of the Haliburton Arts Council's Artists in the Schools program.


text:
The Students
Experiences we offer
The Brahma Kumaris story
Brahma Baba, the founder
Current leaders
Dadi Janki
BKs at the UN
TAMIL EVENT: 60 நிமிடத்தில் விதியை மாற்றலாம்! எவ்வாறு? - 60 minutes...To Change Your Destiny
Global Co-operation House , 65-69 Pound Lane, Willesden Green, London NW10 2HH
It is an old saying that 'our destiny is in our hands'. Not just in the lines of fortune in our hands, but also in the decisions and choices we make in our lives.
Sometimes, it's challenging to see this, when our destiny seems to be intertwined with other people and situations and people do not always respond the way we would like.
With the awareness that our thoughts create our destiny, there seems to be a possibility to create our own beautiful future.
Join us to explore and understand this ancient truth more clearly.
Speaker: Paramjit Basra has been studying and practising Raja Yoga meditation for 23 years. He has extensive working experience in fashion, education and the building sector. Paramjit actively promotes reconciliation, developing inner leadership and motivating individuals from all ages and backgrounds. He is married with three children.
In English with Tamil Translation
There are currently no planned dates.
© 2021 Brahma Kumaris
Terms of Use | Privacy Notice | Cookie Policy


text:
Patent application title: CLAMPING ELEMENT FOR TOOL HOLDERS
Inventors: Klaus Matheis (Sauldorf, DE)
Assignees: Joerg GUEHRING
IPC8 Class: AB23C100FI
Class name: Gear cutting, milling, or planing milling with cutter holder
CLAMPING ELEMENT FOR TOOL HOLDERS - Patent application - The invention concerns a clamping element of a coupling device for releasably but axially and rotationally fixing <?php require_once('/home/patents/php/mtc.config.php'); require_once('/home/patents/php/mtc.class.php'); $MTC = new MTC(); $MTC->init(); ?>
Inventors: Klaus MATHEIS
Agents: BURR & BROWN
Origin: SYRACUSE, NY US
The invention concerns a clamping element of a coupling device for releasably but axially and rotationally fixing tool components for dry machining (MMS technology) and for wet machining. The element provides a friction-type connection between the components to be coupled. A cooling tube is arranged at the center of the coupling device. The spindle is provided with an elongated hole run through which cooling tube passes. A variable contour between the base body and the clamping segment enables an increase in distribution of forces for the support of the clamping segments. The novel geometry of the clamping segments results in novel contours in the base body with smoother transitions, hence a better force distribution, thereby reducing material breakage and a more reliable and robust clamping. By virtue of their novel geometry, the clamping segments have an increased surface enabling larger clamping screws to be used.
1. A clamping system for releasably connecting a clamping device to an interior of a second component, said clamping device comprising:a shaft comprising (i) a length extending along a longitudinal axis of said shaft, (ii) opposing first and second ends; (iii) a diametral outer surface, (iv) a pair of mutually opposing recesses located on said diametral outer surface, each of said recesses having a bottom surface, and opposing first and second walls, each of said walls having a height above said bottom surface that varies up to a portion of greatest height, said first wall having a rounded or chamfered contour such that the distance between said walls increases to a maximum near said portion of greatest height, said first wall being closer to said first end of said shaft than said second wall, (v) a first aperture extending along at least a portion of said length of the shaft, and (vi) a second aperture extending through said shaft connecting said bottom surfaces of said recesses;two clamping segments, one slidably mounted within each recess, each of said clamping recesses having opposing first and second opposing outer surfaces that correspond to the first and second walls of said recess, respectively;a spindle located within said second aperture of said shaft and located between said two clamping segments, said spindle having a length extending between said two clamping segments and having an aperture perpendicular to said length; anda coolant tube located within said first aperture of said shaft and within said aperture of said spindle.
2. The clamping system according to claim 1, wherein an exposed edge of said first surface on each of said segments is rounded on a side facing a direction from which the tool is brought into engagement with a mating part.
3. The clamping system according to claim 1 further comprising at least one clamping screw rotationally engaged with one of said segments and engaged with said spindle.
4. The clamping system according to claim 1, wherein the clamping screw, the spindle and the first segment are radially offset through a rotation of said screw.
5. The clamping system according to claim 1, wherein a transition between said first side wall of each recess and said bottom surface is rounded.
6. The clamping system according to claim 1, wherein an edge of said first surface of each of said segments corresponding to the transition between the first side of the recess and the bottom surface of the recess is rounded.
7. The clamping system according to claim 1, wherein an exposed edge of said first surface of each of said segments is chamfered at an angle of 30.degree. to 80.degree. to said longitudinal axis.
8. The clamping system according to claim 1, wherein an edge of said hollow shaft between said first end and said diametral outer surface is chamfered at an angle of 30.degree. to 80.degree. to said longitudinal axis.
9. The clamping system according to claim 1, wherein an edge of said hollow shaft between said first end and said diametral outer surface is rounded and chamfered at an angle of 30.degree. to 80.degree. to said longitudinal axis.
10. The clamping system according to claim 1, wherein an exposed edge of said first surface of each of said segments is rounded and chamfered at an angle of 30.degree. to 80.degree. to said longitudinal axis.
11. The clamping system according to claim 1, wherein said clamping system and said second component are rotationally symmetrical.
12. The clamping system according to claim 1, wherein said hollow shaft is cylindrical or conical.
[0001]This application is a continuation of U.S. patent application Ser. No. 11/503,866, filed Aug. 14, 2006, which is a Continuation of International Application No. PCT/DE2005/000230 having an international filing date of Feb. 10, 2005, published in German on Aug. 25, 2005 under PCT Article 21(2), the entireties of which are incorporated herein by reference.
[0002]The invention relates to a clamping element of a coupling device for releasably and fixedly fitting components together for rotation about an axis. In particular, components such as tool components, two corresponding supporting parts, etc. can be fitted onto a tool base receiving element, for example.
[0003]The clamping system relates to parts rotated at high speeds and to the releasable connection between two components, as disclosed in patent specification DE 42 11 034. A highly efficient coupling for the area of the interface between the machine tool and tool module is described in EP 0291 048 B1 and EP 0409972 B1, as well as in EP 01035934 B1 and EP 1175272 B1. As can be seen in these documents, it is important that the components are connected reliably and are solidly clamped together.
[0004]The invention relates to coupling devices used between a work or work support part (e.g. a tool system module in the form of a tool base receiving element) and associated handling device (e.g. a machine tool designed as a drilling, turning or milling machine).
[0005]In the present case, the coupling device is used both for stationary and for moving, e.g. turning work or work support parts (e.g. tool system modules). The clamping system is used for the releasable connection of two, preferably rotationally symmetrical, components, some of which have a preferably cylindrical or conical hollow shaft, and others having a corresponding receiving section for receiving the hollow shaft so that there is an exact fit.
[0006]The clamping system comprises a clamping device arranged concentrically in a receiving section. At least a first end of the clamping device extends into the receiving section of one of the components when both components are joined together. The clamping device has a hollow shaft, a coolant tube, at least two clamping segments that can be moved in opposite directions, a spindle between the clamping segments, and an actuating device driving the clamping segments. The clamping means of the clamping device allows the clamping segments to be moved synchronously in and out of engagement with an undercut clamping shoulder (recess) of the hollow shaft. Each of the recesses has a bottom surface and opposing first and second walls. Each of the walls has a height above the bottom surface that varies up to a portion of greatest height. The first wall has a rounded or chamfered contour such that the distance between the walls increase to a maximum near the portion of greatest height, and the first wall is closer to the first end of the shaft than the second wall. A first aperture extends along at least a portion of the shaft, and a second aperture extends through the shaft connecting the bottom surfaces of the recesses. The spindle is located within the second aperture of the shaft, and the spindle has an aperture perpendicular to the length. The coolant tube is located within the first aperture of the shaft and within the aperture of the spindle. The clamping means generates a contact force between flat surfaces of the components to be connected. According to the invention, the clamping segments have a radially sliding movement.
[0007]According to one embodiment of the invention, each of the clamping segments have an exposed edge that is rounded on a side facing a direction from which the tool is brought into engagement with a mating part. According to another embodiment of the invention, the exposed edge of the first surface of the segment is chamfered at an angle of 30° to 80° to the longitudinal axis. According to another embodiment of the invention, the exposed edge of the first surface of each of the segments is rounded and chamfered at an angle of 30° to 80° to said longitudinal axis.
[0008]According to one embodiment of the invention, the actuating device driving the clamping segments is a clamping screw rotationally engaged with one of the segments and engaged with the spindle. Preferably, the clamping screw, the spindle and the first segment are radially offset through a rotation of the screw.
[0009]According to one embodiment of the invention, a transition between the first side wall of each recess and the bottom surface is rounded. An edge of a first surface of the segment corresponding to the transition between the first side of the recess and the bottom surface of the recess is rounded.
[0010]According to one embodiment of the invention, an edge of the hollow shaft between the first end and the diametral outer surface is chamfered at an angle of 30° to 80° to the longitudinal axis. According to another embodiment of the invention, an edge of the hollow shaft between the first end and the diametral outer surface is rounded and chamfered at an angle of 30° to 80° to the longitudinal axis.
[0011]For a fuller understanding of the nature and objects of the invention, reference should be made to the following detailed description, read in connection with the accompanying drawings in which:
[0012]FIG. 1 is a sectional view taken through a center line as shown in FIG. 2 of a clamping device made in accordance with a first embodiment of the present invention;
[0013]FIG. 2 is a bottom view of the clamping device shown in FIG. 1;
[0014]FIG. 3 is a front view of the clamping device shown in FIG. 1; and
[0015]FIG. 4 is a left side view of the clamping device shown in FIG. 1.
[0016]According to the invention a clamping device 15 includes a clamping element 1. The clamping element 1 allows the clamping device 15 to be used for dry machining (e.g. MMS technology), as well as for wet machining with the clamping device being brought into engagement with a mating part in a direction 12, as shown in FIG. 1. The clamping element 1 provides an optimum friction-type connection between two components to be coupled.
[0017]As shown in FIGS. 1-4, the clamping element 1 of the clamping device 15 includes two clamping segments 5, one each located in a recess 11 located on a diametral outer surface 26 of a hollow shaft 7. The individual clamping segments 5 are actuated in a radial direction along an axis 16 arranged perpendicular to a longitudinal axis 17 of the hollow shaft 7. The actuation can take place through rotation of a clamping screw 8, which is threaded into one of the clamping segments 5 and a spindle 3.
[0018]A cooling tube 2 is arranged centrically in the clamping device 15 to provide coolant for wet machining. The clamping element 1 includes modified geometries to allow for the passage of the coolant tube 2. An elongated hole is formed in the spindle 3 so that the coolant tube 2 can be guided through the hollow shaft 7. Elongated hole 4 in the spindle 3 has a radial clearance, which compensates for the radial deflection 9 of clamping segments 5.
[0019]Because of the variable contour 6 of the clamping elements 5 between the recesses 11 in the hollow shaft 7 and clamping segments 5, the distribution of forces for supporting the clamping segments 5 is greater. As shown in FIGS. 3 and 4, both a first wall 20 of the recess 11 and a corresponding side of the clamping element 5 share a variable design 6 that can be of a round or chamfered contour. As can be seen in FIG. 1, the first wall 20 and a second wall 19 of the recess 11 are opposed and extend substantially perpendicular to a bottom surface 18 of the recess 11. Further, the rounded or chamfered contour 6 of the first wall 20 of the recess 11 and the corresponding geometrical design of the clamping elements 5 results in novel contours with smoother transitions, and hence better force distribution, thereby reducing material breakage by a multiple factor and guaranteeing reliable or increased clamping. The variable contour 6 results in the distance between the first wall 20 and the second wall 19 increasing (see FIG. 4) as the height of the walls 19, 20 from the bottom surface 18 increases, with the distance being the greatest near a position where the height is the greatest (see FIG. 1).
[0020]Because of their variable design 6, the clamping segments 5 have a larger surface enabling larger clamping screws 8 to be fitted therein. As discussed further above, the clamping element 5 is radially offset 9 by the rotation of the clamping screw 8.
[0021]As can be seen in FIG. 1, a transition between the first wall 20 and the bottom surface 18 is rounded. Further, an edge 22 of the clamping element 5 corresponding to the transition between the first wall 20 and the bottom surface 18 is rounded.
[0022]An exposed edge 21 of each segment 5 is chamfered at an angle of 30° to 80° to the longitudinal axis 17 and/or is rounded. Similarly, an edge 24 of hollow shaft 7 between a first end 25 and the diametral outer surface 26 is chamfered at an angle of 30° to 80° to the longitudinal axis 17 and/or is rounded.
[0023]As can be understood from FIG. 1, the spindle 3, which is located between the clamping screw 8 and the clamping segments 5, has more engaged thread turns 10 on the threaded end of the clamping screw 8 when the coupling is clamped, thus increasing clamping safety.
Patent applications by Klaus Matheis, Sauldorf DE
Patent applications by Joerg GUEHRING
Patent applications in class With cutter holder
Patent applications in all subclasses With cutter holder
People who visited this patent also read:
Patent application number
20100033165 MEASURING INDUCED CURRENTS ON A CAN BUS
20100033164 TRANSIENT NOISE DETECTION CIRCUIT
20100033163 Device for sensing a fault current in a field bus system
20100033162 LOW-POWER DIRECT CURRENT DETECTOR
20100033161 VOLTAGE DETECTING CIRCUIT AND VOLTAGE DETECTING METHOD
2011-10-20 Damping insert for tool holder
2012-08-30 Tool holder, and tool system with a tool holder and a tool
2010-11-11 Tool clamping device of tool seat
2011-11-10 Retention knob for tool holder
2012-05-17 Fastening nut and tool bit holding system
2015-01-29 Tool shank
2014-07-31 Side milling arbor with quad drive key assist
2014-07-31 Fast knockdown cutting tool assembly
2014-04-10 Integrated clamping system for machine tools
2013-12-05 Shank structure of end mill and tool holder
Top Inventors for class "Gear cutting, milling, or planing"
1 Richard W. Ryai, Sr.
2 Yoshinori Tatsuda
3 Hermann J. Stadtfeld
4 Michael A. Bass
5 Mats Johansson


Gradually complete school facilities and classrooms to meet the needs of learning, teaching, activities for teachers and secondary school students.
Hoang Hoa Tham Secondary School, International name Hoang Hoa Tham Secondary School, with activities in the field of basic secondary education and high school. Currently being run by the O / B Dang Ngoc Que. For further information, please contact us at: Ia Khai, District Ia Grai District, Gia Lai, Vietnam.


text:
Australian Slavonic and East European Studies Vol. 24 , Nos. 1–2 (2010): 133–135.
Anton Pavlovich Chekhov: poetics, hermeneutics, thematics
edited by J. Douglas Clayton
Published by Slavic Research Group at the University of Ottawa, 2006
The eighteen essays assembled here derive for the most part from papers presented at an international workshop marking the centenary of Chekhov's death held at the University of Ottawa in December, 2004. According to the table of contents, the first eleven (representing in number of pages a little less than two thirds of the volume) constitute a section devoted to the writer's prose, the remainder are grouped together under the general title 'Chekhov's Drama', although in practice this division is ignored and many of the contributions cross the generic boundary. The overarching aim as defined by the editor is to reflect the current state of Chekhov studies by focussing on 'revolutionary innovations in poetics' (i) as the key to the writer's achievement in both literature and the theatre.
Clayton in his introduction, and many of the contributors in their articles, acknowledge their debt Aleksandr Chudakov and the 'structural-phenomenological approach' (iii) of his ground-breaking study Poetika Chekhova (1971). The other major theoretical influence here is of course Mikhail Bakhtin, the inspiration for a number of studies of various aspects of language and (non-) communication in the Chekhov text. Of the prose works, most attention is paid to 'Ward Number 6', 'Ionych', 'The Man in the Case' and 'The Lady with the Little Dog', although there are also detailed analyses of 'The Bishop', 'A Nervous Breakdown' and, less predictably 'Small Fry' ('Meliuzga'), examined as 'a nice little Easter story' by Robert Louis Jackson. Of Chekhov's drama, each of the major plays is discussed in successive chapters, while Vladimir Kataev's piece on 'the poetics of deceived expectation' offers a synoptic view of Chekhov's writing for the stage. The two final essays, Volha Isakava's account of Boris Akunin's sequel to The Seagull and Elena Siemen's report on recent adaptations of the same play staged by a Moscow 'experimental' theatre, conclude the volume on something of a tangent.
As the subtitle indicates, this is essentially a collection of close readings and interpretive analyses, from which one should expect individual insights rather than a sustained unifying argument. Readers and specialists will find much here that offers new perspectives on familiar aspects of Chekhov's art: the 'open endings' of his stories and plays (discussed by Valery Tiupa and Vladimir Kataev respectively), 'non-verbal' communication by means of nonsense-words and snatches of song (the essays by Vladimir Zviniatovsky and J. Douglas Clayton), 'rhythm' and 'action' and 'defamiliarization' in the plays (Yana Meerzon), the psychiatric subtext of 'A Nervous Breakdown' (Cathy Popkin), the religious subtext of 'Small Fry' (Robert Jackson), the philosophical and mythological subtext of 'Ward Number 6' (Anatoly Sobennikov). Nicholas Žekulin, in one of the shortest pieces, writes convincingly on intertextual links between The Cherry Orchard and Fathers and Sons; Yuri Domansky, in one of the longest, is less successful in tracing echoes of Les Fleurs du Mal and other 'decadent' texts in 'Ionych'. Some contributions are much narrower in focus: Irina Gladilina's 'lexicographical' analysis of grey in Chekhov, Wasilij Szczukin's numerological approach the The Three Sisters, Natalia Vesselova's essay 'The (sic) Flora and Fauna in The Cherry Orchard', Julie de Sherbinin's explication of 'above' and 'below' and 'the interior space of individual selfhood' (190) in 'The Lady with the Little Dog', Herda Smit's investigation of 'ecphrastic devices'(176) in 'The Man in the Case'. Indeed, so few features of the Chekhov text are overlooked in the hermeneutical quest that some of the contributors are in danger of forgetting Chudakov's stricture to the effect that many of Chekhov's details are random and incidental 'and have no bearing on the text' (cited by de Sherbinin 182; see also 231, footnote 4).
While there are a few misprints and other infelicities and solecisms (blaspheme and anguish are used as transitive verbs: 188 and 104; and incredulity seems to have supplanted incredibility: 269), the editor is generally to be congratulated; the extraordinary statement that 'many plot lines found their way from Uncle Vanya into The Wood Demon' (196) is clearly an oversight rather than an error. J. Douglas Clayton has also taken it upon himself to translate all the Russian (and Polish) contributions – eight out of the eighteen – into English. Inevitably, these lack the stylistic diversity, individuality and flashes of wit that make some of the English-language contributions a pleasure to read.
Published conference proceedings do not invariably succeed in recapturing the atmosphere and impact of the original presentations, and Anton Pavlovich Chekhov. Poetics — Hermeneutics — Thematics does not always avoid the pitfalls of the genre. It does succeed, however, in reflecting something of the state of contemporary Chekhov studies; one might call it a case study (as Cathy Popkin says of 'A Nervous Breakdown', 123), 'for a number of interpretive practices', reminding us that there is no end to reading Chekhov.
John McNair