techniques

A technique is a procedure to complete a task : read more at WikiPedia

  • Some nice reading on AOP...

    Aspect-oriented programming (AOP) is an exciting new paradigm that should have the same effect on software development that object-oriented programming (OOP) had 15-20 years ago. AOP and OOP are not competing technologies, but actually complement each other. OOP is great for modeling common behavior on a hierarchy of objects.

    In software engineering, the programming paradigm of aspect-oriented programming (AOP), also called aspect-oriented software development (AOSD), attempts to aid programmers in the separation of concerns, or the breaking down of a program into distinct parts that overlap in functionality as little as possible. In particular, AOP focuses on the modularization and encapsulation of cross-cutting concerns. from WikiPedia


    What's keeping you from trying out AOP? Whether you think it's only good for low-level functions like tracing and logging, worry that it'll get in the way of unit testing, or would simply rather stick with the object-oriented alternatives, Ramnivas Laddad gives you good reason to reconsider. Follow along as this popular author and speaker digs beneath the surface of 15 myths that hinder the adoption of AOP.(IBM)
  • Decouple an abstraction from its implementation so that the two can vary independently.

    from the gang of the four





    Source Code

    /**
     * Defines Abstraction interface. Stores reference to implementation.
     * 
     * @role __Abstraction
     */
    public abstract class Abstraction {
    	/** Reference to actual implementation */
    	private Implementor impl;
    
    	/**
    	 * @return implementation-in-action.
    	 */
    	protected Implementor getImplementor() {
    		return impl;
    	}
    
    	/**
    	 * This sample operation delegates call to particular implementation
    	 */
    	public void someOperation() {
    		getImplementor().someOperationImpl();
    	}
    }
    
    /**
     * Concrete implementation
     */
    
    public class ConcreteImplementorA extends Implementor {
    	/** @see patterns.gof.bridge.ImplementorsomeOperationImpl() */
    	public void someOperationImpl() {
    		// provide implementation here
    	}
    }
    
    /**
     * Concrete implementation
     */
    
    public class ConcreteImplementorB extends Implementor {
    	/** @see patterns.gof.bridge.ImplementorsomeOperationImpl() */
    	public void someOperationImpl() {
    		// provide implementation here
    	}
    }
    
    /**
     * Defines interface for implementation classes. Is not oblidged to provide
     * one-to-one correspondence to interface of Abstraction.
     * 
     * @role __Implementor
     */
    
    public abstract class Implementor {
    	/** Implement this method to provide implementation-specific behavior */
    	public abstract void someOperationImpl();
    }
    
  • 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 {
    }
    
    
    
    
    
    
    
  • null
    Interesting dicussion on www.runryder.com

    Definition:

    Piro Flips with a rotating motion..meaning you would keep executing the flip at a different point, i.e (12:00, 3:00. 6:00, 9:00, 12:00).

    Credit to Augusto (www.)

    "A good controlled sustained piroueting flip will have the rotor disc flipping in the same direction while the tail pirouettes around the main shaft axis.
    Not too many people can do a good sustained piroflip. Most people piroflip and kind of "catch it" over and over so the disc is not flipping in the same direction.
    Now a chaos is a sustained piroflip where the pilot purposely and in a controlled manner does a maintained piroflip and slowly rotates the flipping axis 360 degrees to a full turn of the flipping axis.
    The big deal about this maneuver is that it shows that you have complete control of the sustained piroflip in any orientation of the flipping rotation.
    I have never seen anyone do a real chaos and Curtis told me he either saw or performed a good one only once or twice.
    Lately I&39;m practicing piroflipping rolling circles or maybe simply called piruetting rolling circles as a way to practice for when I try a real chaos. It will be the same as far as orientations is concerned but without the translational movement. Keeping it in a single place while slowly rotating the direction of the flipping is pretty tough.

    Regarding the circle, It&39;s important to understand that in the pirouetting flip the numbers of pirouettes per flip are not related or set in stone. You can describe a full flip while doing say 10 pirouettes or even a ful flip with say 6 pirouettes. Obviously given a certain constant pirouetting speed the lower the number of pirouettes the faster the flipping portion of the mainblades disc.

    The factor that controls how fast the flipping happens is the total amount of deflection away fom the center you apply. In other words the larger the "stirring circle" the higher the swashplate deflection hence the faster the flipping rate. Doing very small "stirring circles" in the cyclic will achieve slowly flipping piroflip that has a relatively fast pirouetting rate. Conversely applying a large deflection away from the center i.e. large "stirring circle" will make it look like a pretty fast flip with proportionally fast pirouettes.

    What I call "piro-cheating" while piroflipping is when people let it rest for a while while in the horizontal disc portion of the flip whether it&39;s right side up or inverted for about two full pirouettes and then continue with the piroflip. They let it rest a bit and then apply upwards momentum so that they can do the piroflip while hanging between upwards pushes. That makes the piroflip a lot easier but also a lot uglier. Doing a piroflip where the flipping of the disc has a constant rate of flip is a completely different animal. It&39;s obvious that there has to be upwards momentum applied but people need to learn how to make it happen without stopping the flipping portion to regain momentum. There&39;s a world of pitch management that happens in that small amount of time.

    Take a look at this clip and notice that the flipping stays constant and there&39;s no resting time when the disc is horizontal. Also in this case the deflection circle is small and as you can see there is a high number of fast pirouettes for each flip. Notice also how the direction or orientation of the flipping portion stays somehow constant throughout the piroflip. The clip is not too good an example but it servers the purpose of illustrating the mechanisms of what I&39;m explaining.
    "

    Totally agree with Augusto&39;s posts. Work on your timing first to get the flips so the rotor disk constantly flips in the same direction. Then you can work on rotating the flipping direction.

    Other than increasing cyclic at a particular point to &39;shift&39; the pirouetting flip or the chaos in a certain direction, I find thottle/pitch management important to be able to control the whole manouver. After increasing cyclic of your desired direction,depending on how far/fast I want to travel, I would also add a little extra throttle to the flip but in the direction I want to move. This is more important for when you do piro-flippin&39; loops or fly around doing constant piroeutting flips.

    Piroflip and Chaos Practice
    Credit to Pete Niotis

    "PiroFlip Practice: Keep doing a repeated async pirouetting loop in the same spot. Make smaller/tighten as you progress...that&39;s it!
    Chaos Practice: A series of very small/tight Async Pirouetting Loops where each complete little async pirouetting loop keeps being placed/rotated in a different location relative to the flight line. For example...spool up heli side in (nose right for this example), climb to a comfortable height let&39;s say 10-20 feet and go right into a tail stand, begin a constant pirouette dropping and forming a radius within a few decending feet while pirouetting and begin forming another pirouetting radius travelling to your right as to make heli ascend knife edge while pirouetting where now the outside of disc is facing right as you get to the top, at the top or end of the climb start adding negative collective while still pirouetting which leads you to the same spot you started with the exception that now the inside of disc is facing left side of field and here&39;s where you would drop to start another tight async pirouetting loop but you would also add the necessary cyclic inputs to place next loop at 12:00 or 6:00 position all dependant on which way you prefer or which way of rotation compliments the flow of your chaos. Keep in mind that placing each async pirouetting loop 90 degrees from last position will probably not be as good as placing each 45 degrees from the last position. To simplify understanding all this...practice these async pirouetting loops bigger at the beginning and just keep tightening them up and making them smaller as you progress and you&39;ll soon have a chaos."
    null

  • Still hesitating about using or not using regression tests in your code? (JUNIT for java for ex.) Look here at Failed fixes haunt credibility of Microsoft's Trustworthy Computing Initiative. Even Microsoft has some problem today...because they do not have invested enough time/money/power into it....

  • Â Read this document about classloader (PDF)
    • System classloader is the content of the system variable CLASSPATH= you defined higher level
    • Loader of the servlet runner is own classloader of Resin, tomcat or other
    • Application classloader (controlled by resin or tomcat) find classes which are in the webapps directory (Application class).
    • Your own classloader if you write own lower level

    As soon as you request a class in one of these loader, the classloader will take the first found during its walk under this rules:

    • if the class is not found at the current level (place where you request it, most of the time in your application), it will try to load it from the upper level, if not found it will continue and finish in the system classloader.
    • There is no downward request.
  • Call task1, if the variable contains 'true', 'on', or '1' the task 'send a sms alert' is executed
    
    
    
    
    
    
  • A properties file in c:/confA commentstmp.path=c:\tempftp.login.default=cedricwalterftp.pwd.default=xxxxftp.host=ftp.adress.comftp.port=21
    
    
    
    
    
    
  • This script ask for security reason the login and password. (but accept default values)
    
    
     
    
    
    
     
    
    
    
    
    
    
  • This script ask for security reason the login and password. (but accept default values)
    
      
    
    
    
    
    
    
    
    
    
    
    
    
    
    
  • Impact of Zend Optimizer on PHP Performance

    The Zend Optimizer FAQ answers the question "Why use the Zend Optimizer?" with this statement: "The standard Zend run-time compiler used by PHP is indeed extremely fast, generating code that is usually 2 to 10 times faster. But an application that uses the Zend Optimizer typically executes another 40% to 100% faster."

    Read the results of the load test HERE.

  • port.knocking.ssh.linux

    Port Knocking is a technique to secure services behind a firewall until a specific knock sequence is given. Once that sequence is given, the IP address that initiated the knock may be allowed to access the service for a short period of time. A knocking server listens to all traffic on an Ethernet (or PPP) interface, looking for special "knock" sequences of port-hits. A client makes these port-hits by sending a TCP (or UDP) packet to a port on the server.

    This is a bit paranoid, but it add another layer of security, an attacker will have either to try all ports combinations or know the secret combination (knock) to be able to connect to your SSH daemon for example.

    First, you’ll have to be sure to have a port knocking client, or you will be kick out forever of your own server!

  • subversion_logo-384x332 geeko plesk.logo Subversion (SVN) is an open source version control system. It allows users to keep track of changes made over time to any type of electronic data. Typical uses are versioning source code, web pages or design documents.

    I now host my own private subversion at http://svn.waltercedric.com

    A required step to be able to build some small project and finish the prototype of Continuous build for Joomla!

     

  • openid-logo-2&160; I have now way to many sub domains and websites to not try to make the registration or login process more easier

    Each of the above domains/sub domains has its own registration and login process. I would like as soon as possible try to make people register only once and let them have an easy access to all these services.

    SSO

    Single Sign on?

    Basically One solution would be likely to use OpenID

    OpenID is an open, decentralized standard for user authentication and access control, allowing users to log onto many services with the same digital identity. As such, it replaces the common login process that uses a login-name and a password, by allowing a user to log in once and gain access to the resources of multiple software systems. [WikiPedia]

    Advantages

    • Joomla, Bamboo, JIRA are able to use OpenID
    • More than 200 million users worldwide
    • Free implementation and sometimes even some ready to use plugin

    But

    1200 users are registered, and how do I migrate them all??? not all are active but I can just delete their account…