Software Developer Homemade StudyGuide YO!!

Study Links

Github----
http://unethicalblogger.com/2010/04/02/a-rebase-based-workflow.html
https://www.atlassian.com/git/tutorials/comparing-workflows/gitflow-workflow
https://www.youtube.com/watch?v=3m7BgIvC-uQ

Android----
http://petrnohejl.github.io/Android-Cheatsheet-For-Graphic-Designers/
https://github.com/futurice/android-best-practices
http://corner.squareup.com/2014/01/mortar-and-flow.html
http://square.github.io/dagger/
https://github.com/square/mortar
http://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/

Java----
http://www.java2novice.com/java-collections-and-util/
http://www.vtc.com/products/Advanced-Java-Programming-Java-SE7-Tutorials.htm




What? How? Why?
----------------
https://github.com/square/mortar

Mortar - used to pair thin views with dedicated controllers(Presenters)

Relies on Dagger and the Android Runtime and uses dagger to @Inject whatever is needed 

This allows sigletons to be used at all parts of the app
@Singleton and Removes the hassle of dealing with fragments and testing on a big project

--------
https://github.com/square/flow

Flow - a small library that helps with describing an app as a collection of moderately independent screens.  These screens can be pushed onto a concrete backstack to provide navigation history.

Screen- describes a distinct state of an application.  Contains enough information to bootstrap the view.
BackStack- the history of screens, with the head being the current or last most screen

Easily transition between screens with a simple command.  This is more efficient than using fragments

--------
http://techblog.netflix.com/2013/02/rxjava-netflix-api.html
http://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/

RxJava - A library that Offers efficient execution and composition by providing a collection of operators capable of filtering, selecting, transforming, combining and composing Observables.

Basic Building Blocks of Observables and Subscribers.  Observerables emits items;  Subscribers consume those items

Embraces Concurrency, reduces network chattiness.  Java Futures are usually expensive when asynchronous executions are nested.

--------
http://jakewharton.github.io/butterknife/

ButterKnife - Used for @InjectView to inject views without having to deal with the hassle of XML

Instead of slow reflection, code is generated to perform the view look-ups as it is being used

This is faster and easier to use and avoids the hassle of an xml

--------
http://square.github.io/dagger/

Dagger - A replacement for the clases that don't do much and allows you to inject dependencies as needed,

Don't need a bunch of boilerplate just to swap  anything

--------
http://developer.android.com/training/volley/simple.html

--------
http://developer.android.com/training/volley/simple.html

Volley
Handles Network calls as needed


--------
http://robolectric.org/

Roboelectric
Allows us to run tests within our IDE

Robolectric handles inflation of views, resource loading, and lots of other stuff that’s implemented in native C code on Android devices. This allows tests to do most things you could do on a real device. It’s easy to provide our own implementation for specific SDK methods too, so you could simulate error conditions or real-world sensor behavior, for example

Annotations
--------
http://isagoksu.com/2009/creating-custom-annotations-and-making-use-of-them/
http://techo-ecco.com/blog/spring-custom-annotations/
http://stackoverflow.com/questions/10205261/how-to-create-custom-annotation-with-code-behind

@Retention  Marks annotation to be reserved at Runtime


public @interface MyMessageDriven{
 }

//And you have an interface that can apply annotation like this:

public interface MyMessagListener {

    public void message();
}



@MyMessageDriven  
     public class MyMessage implements MyMessagListener  {
      public void message(){
        System.out.println(" I am executed");
      }
     } 

   --------
   Assertions

   Assertions can function as a form of documentation: they can describe the state the code expects to find before it runs (its preconditions), and the state the code expects to result in when it is finished running (postconditions);

   --------
   Deligation

   Delegation is the simple yet powerful concept of handing a task over to another part of the program. In object-oriented programming it is used to describe the situation where one object assigns a task to another object, known as the delegate. This mechanism is sometimes referred to as aggregation, consultation or forwarding