pattern

A pattern, apart from the term's use to mean "Template", is a discernible regularity in the world or in a manmade design. read more at WikiPedia

  • Agile testing is a software testing practice that follows the principles of agile software development. Agile testing is built upon the philosophy that testers need to adapt to rapid deployment cycles and changes in testing patterns. Providing and getting feedback early, fast and regularly is one of the testers main task.

    AgileTestingPoster

    From http://bbv.ch/images/bbv/pdf/downloads/poster/bbv12_poster_agile_testing_1.0_web.pdf

    You can order a print version at http://www.bbv.ch/de/posterbestellung.html

    Find more at http://bbv.ch/de/unternehmen/publikationen.html

  • Design good code is a small code! responsabilities must be properly localized (do not be lazy, create more objects!) and not spread around or worse localized in one object (spaghetti code) 

  • Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.



    Source code

    /**
     * Declares an abstract Interpret operation that is common to all nodes in the
     * abstract syntax tree.
     * 
     * @role __InterpreterExpression
     */
    public abstract class AbstractExpression {
            public abstract void interpret(Context context);}
    
    /**
     * Builds an abstract syntax tree representing a particular sentence in the
     * language that the grammar defines. Invokes the Interpret operation.
     */
    public class Client {
            public AbstractExpression getExpression() {
                    // put your code to create expression here
                    return null;        }
    
            public void sampleOperation() {
                    Context context = new Context();                
    getExpression().interpret(context);
    } } /** * Contains information that is global to interpreter. * * @role __InterpreterContext */ public class Context { } /** * One such class is required for every rule in the grammar. */ public class NonterminalExpression extends AbstractExpression { public void interpret(Context context) { // put your code here } } /** * Implements an Interpret operation associated with terminal symbols in the * grammar. */ public class TerminalExpression extends AbstractExpression { public void interpret(Context context) { // put your code here } }
  • Sample Chapter are provided courtesy of Addison Wesley Professional and can be read at  www.informit.com
    What Is Refactoring? A refactoring is a "behavior-preserving transformation" or, as Martin Fowler defines it, "a change made to the internal structure of software to make it easier to understand and cheaper to modify without changing its observable behavior" (Fawler, page 53) read more here


  • You do not create your objects but describe (using cofiguration file) how they should be created and wired together in code. A container (for ex: in case of Spring framework, the IOC container) is then responsible for hooking it all up.

    In a typical IOC scenario, the container creates all the objects, wires them together by setting the necessary properties, and determines when methods will be invoked. The three implementation pattern types for IOC are:

    Type 1 Services need to implement a dedicated interface through which they are provided with an object from which they can look up dependencies (for example, additional needed services).

    Type 2Dependencies are assigned through JavaBeans properties (for example, setter methods).

    Type 3 Dependencies are provided as constructor parameters and are not exposed as JavaBeans properties.


  • AgileRequirementEngineeringPoster

    From http://bbv.ch/images/bbv/pdf/downloads/poster/bbv11_poster_agile_re.pdf

    You can order a print version at http://www.bbv.ch/de/posterbestellung.html

    Find more at http://bbv.ch/de/unternehmen/publikationen.html

  • using UML is the best way to keep everyone talking the same language and agreeing upon how to approach problems with an eye for consistency and easy-understanding for future developers.