architecture

Architecture (Latin architectura, after the Greek ἀρχιτέκτων – arkhitekton – from ἀρχι- "chief" and τέκτων "builder, carpenter, mason") is both the process and the product of planning, designing, and constructing buildings and other physical structures. read more at WikiPedia

  • Zürich, 31. Dezember 2013

    Wir bestätigen gerne, dass Herr Cédric Walter, geboren am 3. Oktober 1973, in Mulhouse/Frankreich, vom 01. Oktober 2007 bis 31. Dezember 2013 in unserem Unternehmen als Senior Software Architect tätig war. Zudem war Herr Walter Aktionär der Innoveo Solutions AG.

    Im Einzelnen umfasste sein Aufgabengebiet;

    Tätigkeiten im Zusammenhang mit der Realisierung unseres Produkts Innoveo Skye®

    • Konzeption, Design und Implementierung funktionaler Erweiterungen, sowie Re-factoring
    • Unterstützung beim Aufbau und der Optimierung unserer Software-Entwicklungsumgebung
    • Bildung von Releases und Durchführung von Deployments
    • Konzeption und Umsetzung von Massnahmen zur Qualitätssicherung und Performance-Optimierung
    • Integration der Apache POI Library, sowie aktive Mitwirkung in der POI Open Source Community   

    Tätigkeiten im Zusammenhang mit der Anwendung unseres Produkts Innoveo Skye®

    • Mitwirkung bei der Implementierung einer Web-Anwendung für den Onlineverkauf von Krankenversicherungsprodukten
    • Mitwirkung bei der Implementierung einer multikanalfähigen Web-Anwendung für einen Kunden in den Vereinigten Arabischen Emiraten
    • Verantwortung für die Konzeption und Umsetzung von Massnahmen zur Qualitätssicherung und Performance-Optimierung bei Kundenanwendungen
    • Mitwirkung an der Weiterentwicklung der Anwendung Syrius der Adcubum AG

    Herr Walter hat zur Umsetzung der ihm anvertrauten Aufgaben in unserer Java-Entwicklungsumgebung und unter Anwendung der agilen Vorgehensmethode Scrum, u.a. folgende Tools jederzeit kompetent eingesetzt:

    • IntelliJ, MS Visual Studio, SVN / GIT, TeamCity, Nexus
    • Java, C#
    • Apache Webserver, Tomcat, Spring, Lucene, MySQL, Oracle, .Net
    • Jira, Jira Agile (vormals Greenhopper), Confluence

    Wir haben Herrn Walter als engagierten, zuverlässigen und pflichtbewussten Mitarbeiter kennen gelernt. Aufgrund seiner sehr guten Fachkenntnisse und raschen Auffassungsgabe arbeitete Herr Walter immer sehr selbständig und effizient. Dies erlaubte es ihm, auch in Zeiten grosser Arbeitsbelastung die ihm übertragenen Aufgaben stets ausgezeichnet und einwandfrei auszuführen. 

    Er zeigte grossen Einsatz und war jederzeit bereit, zusätzlich zu seinen Haupttätigkeiten weitere Aufgaben zu übernehmen. Zusammenfassend waren wir mit seiner fachlichen Kompetenz sowie mit seinen qualitativen und quantitativen Leistungen sehr zufrieden. Ausserdem war er ein loyaler Mitarbeiter, welcher die Interessen der Firma stets ausgezeichnet wahrgenommen hat.

    Auch in persönlicher Hinsicht kann Herrn Walter ein sehr gutes Zeugnis ausgestellt werden. Seinen Vorgesetzten, Kollegen und Kunden gegenüber hat er sich stets freundlich und korrekt verhalten und war ein geschätztes Teammitglied.

    Dieses Zeugnis wird aufgrund einer Firmenübernahme ausgestellt. Wir bedanken uns bei Herrn Walter für seine bisherige stets ausgezeichnete Arbeit und wünschen uns eine noch lange währende positive Zusammenarbeit unter der neuen Firma Pactera Switzerland AG.

    Innoveo Solutions AG

     

    Nicola Stefania                                     Didier Beck
    Managing Partner                                 Managing Partner

     

  • Separate the construction of a complex object from its representation so that the same construction process can create different representations.



    Source Code

    /**
     * The interface Product defines interface to create parts of the
     * Product.
     */
    public interface Builder {
    
        /**
         * Construct part of the complex Product.
         */
        public void buildPart();
    
        /**
         * Construct the Product.
         *
         * @return the constructed product
         */
        public Product getProduct();
    }
    
    /**
     * The ConcreteBuilder is the product of a concrete builder.
     *
     */
    public class ConcreteBuilder implements Product {
    }
    
    
    /**
     * The ConcreteBuilderBuilder creates and assembles parts of
     * the Product.
     *
     */
    public class ConcreteBuilderBuilder implements Builder {
    
        /**
         * Reference to Product being constructed
         */
        private ConcreteBuilder concreteBuilder;
    
        /**
         * Construct part of the complex Product.
         */
        public void buildPart() {
            // put your code here
        }
    
        /**
         * Construct the Product.
         *
         * @return the constructed product
         */
        public Product getProduct() {
            return concreteBuilder;
        }
    }
    
    
    /**
     * The ConcreteBuilderClient initialized the Director with a
     * Concrete Bulder to create the Product and gets result from the Builder.
     *
     */
    public class ConcreteBuilderClient {
    
        /**
         * Use the Builder to create the Product.
         */
        public void createProduct() {
            ConcreteBuilderBuilder builder = new ConcreteBuilderBuilder();
            new Director(builder).construct();
            Product product = builder.getProduct();
        }
    }
    
    
    /**
    * The class Director manages Product creation using Builder.
    */
    public class Director {
    
        /**
         * Reference to Builder currently used
         */
        private Builder builder;
    
        /**
         * Create a new Director instance.
         *
         * @param builder the builder which will create the product
         */
        public Director(Builder builder) {
            this.builder = builder;
        }
    
        /**
         * Construct the Product using the Builder.
         */
        public void construct() {
            builder.buildPart();
        }
    }
    
    
    /**
     * The interface Product defines a complex object that is
     * constructed part-by-part with Builder.
    
     */
    public interface Product {
    }
    
    
    
    
    
    
    
  • Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it.



    Source code

    /**
     * Handles request it is responsible to.
     */
    public class ConcreteHandler extends Handler {
            /**
      * Handle request or delegate it.
      */
            public void handleRequest() {
                    boolean canProcessThisRequest = false;                if (canProcessThisRequest) {
                            // handle request if possible
                    } else {
                            // pass it to the next in chain
                            super.handleRequest();                }
            }
    
    }
    
    /**
     * Defines interface for request handling
     * @role __Handler
     */
    public class Handler {
            private Handler successor;        /** Default request handling */
            public void handleRequest() {
                    if (successor != null) {
                            successor.handleRequest();                }
            }
    
            public Handler getSuccessor() {
                    return this.successor;        }
    
            public void setSuccessor(Handler successor) {
                    this.successor = successor;        }
    
    }
    
    
    
    
    
  • As I am in the middle of the development (a little bit more than 60% done) of my PHP Bayesian Naive Filter (a learning filter against spams comment, guestbook, and posting in general) for Joomla/Mambo and after reading some paper found on internet:

    • On Attacking Statistical Spam Filters, Gregory L. Wittel and S. Felix Wu - Department of Computer Science - University of California, Davis One Shields Avenue, Davis, CA 95616 USA
    • A Naive Bayes Spam Filter, Kai Wei This email address is being protected from spambots. You need JavaScript enabled to view it. CS281A Project, Fall 2003
    • But there is more...

    I decide that my project will be certainly a failure if I rewrite or reuse a Bayesian filter engine which is not accurate or using the latest countermeasures. Since I do not want to develop during 3 years an effective filter (will I ever be able to do it???), I came across the idea of implementing the component com_bayesiannaivefilter in such a way that I can abstract the core engine and use the work done by the best open source project.

    It is also clear for me since the beginning that a spam filter must be trained on a very large data volume (more than 1000 messages, the more the better) in order to categorize the message with accuracy. Webservices will have my preference as an internet entities with the require cpu horsepower and data store should be able to offer the best categorizing messages efficiency....

    My component will be able to use following Bayesian Naive Filter core: (planned but not done, I it is technically possible I will do it)

    Plugins Remarqs Possible open source project
    JAVA I am a J2EE developer, Back to the roots :-) Som. to propose? contact me!
    PHP Core done, but very simple tokenization and hashing of message
    Volume of data small
    Som. to propose? contact me!
    PERL Can PHP call perl code? Som. to propose? contact me!
    CGI-BIN Should be easy to do Som. to propose? contact me!
    WEBSERVICES Should be easy as soon as we found a WS provider
    Data volume?
    Som. to propose? contact me!

    Each technology may contains many core engine, or different versions. I will fill this table with possible candidate (You can heelp me by suggesting or speeding development).

    Core requirement:

    • Use mySQL,
    • Most of internet provider allow the use of CGI-BIN, PERL, JAVA

    This project will be soon committed to Joomla forge!

  • Encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations. Builds an undo/redo manager and a set of  command classes.



    Source Code

    /**
     * Declares an interface for executing an operation
     * @role __Command
     */
    public interface Command {
            /** this method is called by client to execute this command */
            void executeCommand();}
    
    /**
     * Defines a binding betweeen a Receiver object and an action. 
     * Implements Command by invoking the corresponding operation(s) on Receiver
     */
    public class CommandA implements Command {
            public CommandA() {
                    // put command initialization code here
            }
    
            /** @see patterns.gof.command.CommandexecuteCommand()*/
            public void executeCommand() {                 // provide implementation here
            }
    }
    
    /**
     * Defines a binding betweeen a Receiver object and an action. 
     * Implements Command by invoking the corresponding operation(s) on Receiver
     */
    public class CommandB implements Command {
            public CommandB() {
                    // put command initialization code here
            }
    
            /** @see patterns.gof.command.CommandexecuteCommand()*/
            public void executeCommand() {                 // provide implementation here
            }
    }
    
    /**
     * Concrete Command that executes a sequence of Commands.
     */
    public class MacroCommand implements Command {
            /** Commands to execute */
            private Command[] commands;        /** @param commands Commands to execute */
            public MacroCommand(Command[] commands) {
                    this.commands = commands;        }
    
            /** Executes sequence of Commands */
            public void executeCommand() {
                    if (commands != null) {
                            for (int i = 0; i < commands.length; i++) {
                                    commands[i].executeCommand();                        }
                    }
            }
    
    }
    
    
  • Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.



    Source Code

    /**
     * Defines the interface for objects that can have responsibilities added to the
     * dynamically.
     * 
     * @role __Component
     */
    public abstract class Component {
    	/**
    	 * Sample operation.
    	 */
    	public abstract void doSomeStuff();
    }
    
    /**
     * Defines an object to which additional responsibilities can be attached.
     */
    
    public class ConcreteComponent extends Component {
    	/** @see patterns.gof.decorator.ComponentdoSomeStuff() */
    	public void doSomeStuff() {
    		// provide implementation here
    	}
    }
    
    /**
     * Adds responsibilities to the component.
     */
    
    public class ConcreteDecorator extends Decorator {
    	public ConcreteDecorator(Component decorateMe) {
    		super(decorateMe);
    	}
    
    	/**
    	 * Behavior added by decorator.
    	 */
    	private void addedBehavior() {
    		// some extra functionality goes here
    	}
    
    	public void doSomeStuff() {
    		super.doSomeStuff();
    		addedBehavior();
    	}
    }
    
    /**
     * Maintains the reference to a Component object and defines an interface that
     * conforms to Component's interface
     * 
     * @role __Decorator
     */
    
    public abstract class Decorator extends Component {
    	/** reference to the decorated component */
    	protected Component component;
    
    	/**
    	 * @param decorateMe
    	 *            component to decorate
    	 */
    	public Decorator(Component decorateMe) {
    		this.component = decorateMe;
    	}
    
    	public void doSomeStuff() {
    		component.doSomeStuff();
    	}
    }
    
  • 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) 

  • google_logo

    Google’s Jeff Dean was one of the keynote speakers at an ACM workshop on large-scale computing systems, and discussed some of the technical details of the company’s mighty infrastructure, which is spread across dozens of data centers around the world. His presentation give some insight about what’s going on at Google, and how they have found innovative solutions to meet their never ending quest of speed and bandwidth usage. All their figures have impressed me a lot!

    You will learn some of their in house technologies, aka

    • Google File System (GFS): a scalable distributed file system for large distributed data-intensive applications.
    • Map Reduce is a software framework introduced by Google to support distributed computing on large data sets on clusters of computers [WikiPedia],&160; see Hadoop project for a free open source Java MapReduce implementation.
    • BigTable is a compressed, high performance, and proprietary database system built on Google File System (GFS), see Hadoop HBase project for something similar.
    • Their new project: Spanner which will be responsible for Storage & computation system to spans all over their datacenters.

    Read now this great document online http://www.cs.cornell.edu/projects/ladis2009/talks/dean-keynote-ladis2009.pdf (if it disappear, ask me for a copy)

  • At SD Forum 2006, Randy Shoup and Dan Pritchett, both with eBay, gave a presentation on eBay's architecture. Pritchett subsequently posted his presentation slides in his blog, The eBay Architecture.
    Predictably, the presentation contained a few inspiring statistics, such as:
    • 15,000 application instances running in eight data centers
    • 212,000,000 registered users
    • 1 billion page views per day
    • 26 billion SQL queries and updates per day
    • Over 2 petabytes of data
    • $1,590 worth of goods traded per second
    • Over 1 billion photos
    • 7 languages
    • 99.94% uptime

    Other stats in the presentation related to development process and features, such as:

  • Over 300 new features released each quarter
  • Over 100,000 lines of code released every two weeks

"According to the presentation, the goal of eBay's current architecture is to handle an additional ten-fold increase in traffic, something eBay expects to reach within a few short years. Another architecture objective is to be able to handle peak loads, and for components to gracefully degrade under unusual load or in the case of system failures." read more  HERE

 

  • Provide a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level interface that makes the subsystem easier to use.



    Source Code

    /**
     * Knows which subsystem classes are responsible for a request.
     * Delegates client requests to appropiate susystem objects.
     * @role __Facade
     */
    public class Facade {
            /** reference to particular subsystem */
            private SubsystemA theSubsystemA;        /** reference to particular subsystem */
            private SubsystemB theSubsystemB;        /** this method is called by client */
            public void facadeMethod() {
                    // multiple subsystems could be involved
                    // to provide some functionality
            }
    }
    
    /**
     * Implements subsystem functionality. Handles work assigned by the Facade object.
     * Has no knowledge of the facade.
     * @role __System
     */
    public class SubsystemA {
            /** some functionality */
            public void subsystemFunctionality() {
            }
    }
    
    /**
     * Implements subsystem functionality. Handles work assigned by the Facade object.
     * Has no knowledge of the facade.
     * @role __System
     */
    public class SubsystemB {
            /** some functionality */
            public void subsystemFunctionality() {
            }
    }
  • If you want to know a bit more on the infrastructure that is used by Google...

  • A collections of links, this time. A lot of persons have already done a stunning job:

    • Sun Java Center - J2EE Patterns:The J2EE Patterns presented here, a collection of J2EE-based solutions to common problems, reflect the collective expertise and experience of Java technology architects in the Sun Java Center over the past three years.
    • Wiki pattern catalogwith some famous contributors like Kent Beck and co.
    • The server side: get the latest informations on Patterns.
    • Javaworld a list of articles

  •  Meta-Patterns: Design Patterns Explained
    Moisés Daniel Díaz Toledano. Email : This email address is being protected from spambots. You need JavaScript enabled to view it.
    www.moisesdaniel.com

    MetaPatterns can be contemplated like a form of understanding the underlying mechanisms of patterns and the form in which they work, and even as a new patterns’ classification.
    The principal objective of patterns is capturing good practices that allow us to improve the quality of the design of systems, determining objects that support useful roles in a specific context, encapsulating complexity, and making it more flexible.
    We can observe that the structure of these solutions (patterns) repeats, using a series of basic mechanisms (even in different levels of abstraction) to produce the same effects in the system.

  • Books:

    Softwares:

    Analysis

    Structural Analysis for Java"SA4J is a technology that analyzes structural dependencies of Java applications in order to measure their stability. It detects structural "anti-patterns" (suspicious design elements) and provides dependency web browsing for detailed exploration of anti-patterns in the dependency web. SA4J also enables "what if" analysis in order to assess the impact of change on the functionality of the application; and it offers guidelines for package re-factoring."
      

    Metrics

    Metrics sourceforge
    eclipse plugin
     
  • 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.
  • Kyle Cordes’s blog post on the “YouTube Scalability Talk” It’s definitely worth reading!