Java Interview Questions: Know more about Java

 I want to share with you some Java definitions, which a Developer should know. This Java definitions are mostly asked in interviews. So let's have some fun with these java basis ;)

- Java is compiled first to a byte-code, after that it's interpreted by a java virtual machine (JVM)

- The fondamental OOP concepts:

• Encapsulation: Encapsulation can be described as a protective barrier that prevents the code and data being randomly accessed by other code defined outside the class ( done thanks to the accessors: private, public, protected) . Encapsulation is thus referred as data hiding. Protection of the data is tightly controlled by an interface. The main benefit of encapsulation is the ability to modify our implemented code without breaking the code of others who use our code. With this feature Encapsulation gives maintainability, flexibility and extensibility to our code.

• Inheritence: it is the capability of a class to use the properties and methods of another class while adding its own functionality. In OOP, we often organize classes in hierarchy to avoid duplication and reduce redundancy. When we talk about inheritance the most commonly used keyword would be extends and implements. If a class inherits a method from its super class, then there is a chance to override the method provided that it is not marked final. The benefit of overriding is the ability to define a behavior that's specific to the sub class type.
  
  
• Polymorphism: The word "polymorphism" means "many forms". Polymorphism is the ability of an object to take on many forms. The most common use of polymorphism in OOP occurs when a parent class reference is used to refer to a child class object. When a superclass instance is expected, it can be substituted by a subclass instance. A reference to a class may hold an instance of that class or an instance of one of its subclasses - it is called substitutability. With Polymorphism, the instance method that is invoked will be determined only at run-time by the actual class of the object, not by the type of the reference.

- POJOs are objects that have no contracts imposed on them; they don't implement interfaces or extend specified classes.

- main() is declared in  java as public static void beacuse:

• Public - main method is called by JVM to run the method which is outside the scope of project therefore the access specifier has to be public to permit call from anywhere outside the application
• static - When the JVM makes are call to the main method there is not object existing for the class being called therefore it has to have static method to allow invocation from class. 
• void - Java is platform independent language therefore if it will return some value then the value may mean different to different platforms so unlike C it can not assume a behavior of returning value to the operating system. If main method is declared as private then - Program will compile properly but at run-time it will give "Main method not public." error.

- Overriding vs Overloading:

• Overriding means creating a new set of method statements for the same method signature. If a derived class requires a different definition for an inherited method, then that method can be redefined in the derived class. An overridden method would have the exact same method name, return type, number of parameters, and types of parameters as the method in the parent class, and the only difference would be the definition of the method. 
• Overloading in Java can occur when two or more methods in the same class share the same name with at least one of this things is true:

• The number of parameters is different in each method
• The parameters types are different.

• Be aware because we are no longer speeking about overloading if :
• the tow methods have the same name but different return types
• the name of parameters are different.

- There are two ways to reuse the existing classes, namely, aggregation and inheritance. With composition (or aggregation), you create a new class, which is composed of existing classes. With inheritance, you create a new class, which is based on an existing class, with some modifications or extensions.

- Abstarct vs Interface:

• Abstract class is a normal class (containing fields, methods and even constructor (which will be accessed only by subclasses)). For a design purpose, the class should never be instantiated and then defined as abstract (even if it don't contain any abstract method). A class may define some abstract methods with no body specification and subclasses are forced to provide the method statements for their particular meaning. The class should then be explicitely declared  abstract.
• Interfaces are similar to abstract classes but all methods are abstract and all properties (fields) are static final (Constant). Unless the class that implements the interface is abstract, all the methods of the interface need to be defined in the class.  An interface is then defined as a contract of what the classes can do. 

- A java class may implement different interfaces but can extend only one class and only one abstract class.


- Dynamic vs Static method binding:

• Dynamic binding or late-binding  is the ability of a program to resolve references to subclass methods at runtime. During the compilation, the compiler checks whether the method exists and performs type check on the arguments and return type, but does not know which piece of codes to execute at run-time. The problem is that the compiler is unable to check whether the type casting operator is safe. It can only be checked during runtime (which throws a ClassCastException if the type check fails). 
• Static biding is used when the method is declared static (Class Methods). Even if the method is overriding in the subclass, the method used is usually depending on the class reference and is fixed at the compilation. 

 -  Class Methods vs Instance Methods

• Class Methods are methods declared static, these methods can access class variables and class methods directly, but are not allowed to invoke instance variables neither instance methods directly (they must be accessed via object reference)
• Instance Methods are the non static methods. They can access class and instance methods and variables
  

-  Class Variable vs Instance Variable

• Class variable is a static variable whose value is common to all instances and can be access directly by the Class reference.
• Instance Variable is specific to each new instance and is accessed via object reference.

- We use the final keyword in a method declaration to indicate that the method cannot be overridden by subclasses. This is done for reasons of security and efficiency. Accordingly, many of the Java standard library classes are final. All methods in a final class are implicitly final.
- A Java Object is considered immutable when its state cannot change after it is created.To create an Immutable Class, whose state cannot change once created, you need to make the class final and all its members final. It is also possible to make some fields non final and allow modifications only in the constructor.

- Checked vs Unchecked exceptions:

• Checked exceptions must be explicitly caught or propagated as described in Basic try-catch-finally Exception Handling. .
• Unchecked exceptions extend the java.lang.RuntimeException. They do not have to be caught or declared thrown

- In OO Design, it is desirable to design classes that are tightly encapsulated, loosely coupled and highly cohesive, so that the classes are easy to maintain and suitable for re-use.

• Coupling is the degree to which one class knows about another class (The better is to have loosely coupled classes where the communication is done through interfaces and contracts).
• Cohesion refers to the degree to which a class or method resists being broken down into smaller pieces. High degree of cohesion is desirable. Each class shall be designed to model a single entity with its focused set of responsibilities and perform a collection of closely related tasks.

- Constructor chaining occurs through the use of inheritance. A subclass constructor method's first task is to call its superclass' constructor method. This ensures that the creation of the subclass object starts with the initialization of the classes above it in the inheritance chain. The default constructor of the supr-class is implicitely called (if t is not done through this() or super())

- Collections API:

• Set :No duplication allowed and objects are organized with or without order
• Map: Duplication values allowed using different keys and objects can be organized with or without order
• List: Duplication allowed, objects expected to be organized in an order
• Arrays: Duplication allowed, objects expected to be organized in an order, and strongly typed to a particular object type, and lacks ability to resize.

- String vs StringBuilder vs StringBuffer:

• Use a String if the object value will not change because the string is immutable
• When the object value will be manipulated and changed by a single thread, use a StringBuilder because it is unsynchronized (so faster)
• If the object value may be modified by different thread, use a StringBuffer because it is synchronized (thread safe).

- Every thing in Java is pass-by-value.

- Finally is the block of code that executes always. The code in finally block will execute even if an exception is occurred. try{  ...  }catch(Exception e){ ... }finally{  ..... }

That's all for today. Hope that it will be helpful for you :) .

Biblio:

• http://www.tutorialspoint.com/java/java_encapsulation.htm 
• http://www3.ntu.edu.sg/home/ehchua/programming
• http://www.fromdev.com/2012/02/java-interview-question-answer.html 
• http://en.wikipedia.org/wiki/Information_hiding

Customer Relationship Management CRM

I was interested in the Customer Relationship Management (CRM) concept. I have heard a lot of it, and I know the ERP and ESB but not the CRM. That's why, I have decided to invistigate more in this subject.

Customer Relationship Management provids a vision for the way the company wants to deal with the customers. To deliver that vision, the CRM strategy embodies the sales, marketing, customer service and data analysis activities.

Often, the propose of companies is to maximise profitable relationship whith customers by enhancing the relationship for the vender and the customer.

 To attemp this target, the CRM intends to put the customers at the center of the information flow of a company. It thus enables authorised persons on a company to have access to all details about their customers. No need so to contact and wait for informations about the customer from other departments (Sales, finance...).

From Company point of view, all customer are not created equal. The company should be able to identify these high value customers and then service them in a way which keep them loyal. From the customer perspective, the value of the realtionship is not only the product and price but also the quality of customer's interactions with the suppliers (well-understanding of their needs and proposition of relevant offers, response time...).

Here is a brief overview of what I have seen about CRM. I will for sure read more about this application which is essential for the proper functioning of the company.



Biblio:
http://es.atos.net/NR/rdonlyres/9C826F13-D59C-456B-AC57-416E686A4C30/0/crm_wp.pdf

Emotional Intelligence in work: The way to be a good manager

Because the work is not limited to acquire new skills, I was excited when viewing some sudies about Emotional Intelligence.

The four pillars of emotional intelligence are :

• Self Consciousness
• Self control
• Self Motivation
• Empathy
• Management of other's emotions

1 - Self-Consciousness:

 Have a good knowledge about his mood, emotions, and thoughts at any time and the impact of this emotions on his actual behavior.

2 - Self-Control:

It's about the management  of impulsions and emotions in order to assure a good staff rather than create problems which may have serious consequences. The best is so to try to calm down, keep a positif attitude and concentrate despite the stress. But isn't it simple to say it, and so difficult to put it into practice it! Yes it's true, but some solutions where proposed to manage the emotions especially when they arise suddenly. I will speak about this solutions later on.

3 - Self-Motivation: 

Persevere in spite of difficulties and obstacles. I think that the keys of self motivation are: 

• to be confident, and if not to try to acquire this confidence.
• take initiatives and try to change the methods employed before and which didn't give success results
• do not give up at the first attempts and failures

 

 4- Empathy: 

To be aware of the other's feeling and problems. It's also to understand their point of view but not necessarily to be in agreement with them. I think this point enforce the acceptence of others and so the diversity in the campany.

 

5- Management of others' emotions: 

 It's a social intelligence in which a person try to decipher situations, manage his emotions when in contact with other persons and be aware that emotions are contagious.For exemple, when being in contact with stressed people, we feel ourselves stressed also. But by contacting enthusiastic persons, we become like them. The key is then to manage other's emotion by transmitting to them good emotions. A good project manager, is the one who can in addition to his managerial skills, provide good atmosphere in the team. He must understand the emotions of others and change them positively.

The key of success is for sure to have strong knowledges and skills, but without a emotional intelligence, people could not be leaders in their work.
Companies and individuals should be aware of these aspects which are primordial to attempt a real success in the carreer but also in life.

But how to manage their emotions ?

 We cannot manage the time of emotion occurence, but at least, we are able to manage the Emotion Duration and its Intensity.

So to manage the duration and intensity of the emotion, 4 techniques are proposed:

• Distraction
• Self-Observation
• Purge
• Step-back and assess

Let's start with Spring Framwork- Essentials, Conteneur Leger, IoC et Dependency Injection.

Some Definitions :

- The key of the Spring module are:

• Inversion of Control
• Aspect-Oriented Programming: AOP enables behavior tht would otherwise be scattered through different methods to be modularized in a single place (typical concerns are transaction management, logging, failer monitoring)
• Data access abstraction: spirng encourages a consistent architectural approach to data access, and provides a unique an powerful abstraction to implement it.
• JDBC simplification
• Transaction Management: spring provides a transaction abstraction that can sit over "global" transactions (managed by an application server) or "local" transactions using the JDBC, Hibernate...
• MVC web framework

- Spring addresses each layer :

• Presentation layer with the Spring MVC framework which is similar to struts
• Logic layer by using a lighweight IoC container and supporting the AOP (crosscutting aspects such as security, log,...)
• Persistence layer supporting different ORM.

- When you create a bean definition what you are actually creating is a recipe for creating actual instances of the class defined by the bean definition.
- the scopes supported by spring are :

•  singleton, prototype
• request, session and global session : valid in the context of a web-aware Srping ApplicationContext

- The scope of the Spring singleton described as per container and per bean. This means that if you define one bean for a particular class in a single spring container, then the spring container will create one and only one instance of the class defined by this bean definition.
-The prototype scope results in the creation of a new bean instance every time a request for that specific bean is made. You should use the prototype scope for all beans that are stateful, while the singleton scope should be used for stateless beans. The container instantiates, configures, decorates and otherwise assemble a protorype object, hands it to the client and then has no further knowledge of that prototype instance. It is the responsibility of the client code to clean up prototype scoped objects and release any expensive resources that the prototype bean are holding onto.

- The BeanFactory is the actual container which instantiates, configures, and manages a number of beans.
- ApplicationContexts are a subclass of BeanFactory

ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(
        new String[] {"applicationContext.xml", "applicationContext-part2.xml"});
// of course, an ApplicationContext is just a BeanFactory
BeanFactory factory = (BeanFactory) appContext;

- BeanFactory is lightweight, but if you're going to be using Spring "for real", you may as well go with the ApplicationContext
- The ApplicationContext builds on top of the BeanFactory (it's a subclass) and adds other functionality such as easier integration with Springs AOP features, message resource handling (for use in internationalization), event propagation, declarative mechanisms to create the ApplicationContext and optional parent contexts, and Application-layer specific contexts such as the WebApplicationContext, among other enhancements.

Inverion of Control:

-Inversion of Control has already been referred to as Dependency Injection. The basic principle is that beans define their dependencies only through constructor arguments, arguments to a factory method, or properties which are set on the object instance after it has been constructed or returned from a factory method. Then, it is the job of the container to actually inject those dependencies when it creates the bean.

- With IoC, framework code invokes application code, coordinating overall workflaw, rather than application code invoking framework code. It follows the Hollywood Principle where the framework code invokes application code, coordinating overall workflow, rather than application code invoking framework code.
- Dependency Injection is a form of push configuration; the container pushes dependencies into application objects at runtime. this is the opposite of traditional pull configuration, in which the application object pull dependencies from the environment.
- The basic IoC container in Spring is called bean factory
- Spring supports a somewhat more advenced bean factory, called the application context
- An application context is a bean factory with the org.springframework.context.Application context interface being a subclass of BeanFactory.
- In Spring, the controller (DispatcherServlet) controls the view and model by facilitating data exchange between them. No one of the two components is aware of the other component. So the model worry only about the data but not the view.

Ref:

http://www.springsource.org/
Professional Java Development with the Spring Framework, by Rod Johnson et al.

Converting from Hibernate hbm.xml to annotations (JPA)

I am trying to migrate my Hibernate project from mapping using the hbm.xml to the annotations using the Java Persistence API JPA.

During the generation of the mapping files, I have the hbm.xml but also the annotated POJO. Accoding to Hibernate, once we have the *.hbm.xml files and the annotations, the hbm will have the priority and will be then used by default.  In order to change this priority, we can modify the proriety hibernate.mapping.precedence from the default value hbm, class to the new value class, hbm.
So I have done this change in my src/hibernate.cfg.xml file to test it before using the persistence.xml file.

< property name="hibernate.mapping.precedence" > class < / property >

So my persistence.xml file looks like that:

< persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence" >
< !-- Transaction type is jta by default for the JEE environment -- >
    < persistence-unit name="myHibernateSession" transaction-type="JTA" >
      
        < jta-data-source > java:/jdbc/myDatasource < / jta-data-source >  
              
        < properties >
            < property name="hibernate.mapping.precedence" value="class, hbm" / >
            < property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/myDB " / >
            < property name="hibernate.connection.username" value="admin" / >
            < property name="hibernate.connection.password" value="admin" / >
            < property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect" / >
            < property name="hibernate.connection.driver_class" value="org.gjt.mm.mysql.Driver" / >
        < / properties >

    < / persistence-unit >
< / persistence >

While checking in the JBoss server log, I have noticed that Hibernate uses all the time the org.hibernate.cfg.HbmBinder which "Walks an XML mapping document and produces the Hibernate configuration-time metamodel".

Or when using the annotation, the binder should be the org.hibernate.cfg.AnnotationBinder. So I have
removed all my *.hbm.xml files.


When I have tested my solution, I have error telling me that "myHibernateSession not bound" so my hibernate sessionFactory is not bound and thus not working and the access to my data is impossible.
Log :
 get hibernate session
 get hibernate session factory
 myHibernateSession not bound

To initialise the context, we should change the code to  retreive the hibernate sessionfactory  from the entity manager.

EntityManagerFactory emf = Persistence.createEntityManagerFactory("myHibernateSession");

EntityManager em = emf.createEntityManager();    

Session sessionFactory = (Session)em.getDelegate();

All seems to be good now, I test my application and now its works and my session is opened except that I have this error :O
Log:
javax.persistence.PersistenceException: org.hibernate.HibernateException: The chosen transaction strategy requires access to the JTA TransactionManager

When specifying the parameter  transaction-type="RESOURCE_LOCAL", I have read that
"In a Java EE environment, if this element is not specified, the default is JTA. In a Java SE environment, if this element is not specified, the default is RESOURCE_LOCAL."

So I have set the transaction type to JTA, and the error was :

javax.persistence.PersistenceException: org.hibernate.HibernateException: The chosen transaction strategy requires access to the JTA TransactionManager

The solution was to add this property to my persistence.xml file

< property name="hibernate.transaction.manager_lookup_class"

value="org.hibernate.transaction.JBossTransactionManagerLookup" / >

or this one if your are not using JBOSS

< property name="hibernate.transaction.manager_lookup_class" 

 value="com.atomikos.icatch.jta.hibernate3.TransactionManagerLookup" / >

Yopiii, Now all is well working. 
 

Resolved : JBOSS Installation on Eclipse

Installation de JBoss Tools:

Aujourd'hui j'installe JBOSS Tools sous eclipse.  Au cours de cette installation, j'ai commencé par installer eclipse, svn pour la récupération des codes source puis JBOSS Tools 3.3. Par la suite j'ai procédé à la récupération des codes et la, une erreur :

An internal error occurred during: "Initializing Java Tooling".

java.lang.NullPointerException


La deuxième tentation, j'ai installé Eclipse et svn, puis j'ai récupéré le code souce. Tout s'est bien passé. J'ai donc installé Jboss Tools et la, une erreur s'est encore produite et je n'arrive plus à accéder à mon code source
!ENTRY org.eclipse.jface 2 0 2012-05-25 08:48:55.364
!MESSAGE Keybinding conflicts occurred.  They may interfere with normal accelerator operation.
!SUBENTRY 1 org.eclipse.jface 2 0 2012-05-25 08:48:55.365
!MESSAGE A conflict occurred for ALT+CTRL+P:
Binding(ALT+CTRL+P,
 ParameterizedCommand(Command(org.eclipse.team.svn.ui.command.CreatePatchCommand,Create Patch...,
  ,
  Category(org.eclipse.team.svn.ui.command.category,SVN,null,true),
  org.eclipse.team.svn.ui.action.local.CreatePatchAction,
  ,,true),null),
 org.eclipse.ui.defaultAcceleratorConfiguration,
 org.eclipse.ui.contexts.window,,,system)
Binding(ALT+CTRL+P,
 ParameterizedCommand(Command(org.jboss.tools.maven.ui.commands.selectMavenProfileCommand,Select Maven Profiles,
  ,
  Category(org.eclipse.ui.category.window,Window,null,true),
  org.jboss.tools.maven.profiles.ui.internal.ProfileSelectionHandler,
  ,,true),null),
 org.eclipse.ui.defaultAcceleratorConfiguration,
 org.eclipse.ui.contexts.window,,,system)
!ENTRY org.eclipse.core.resources 4 2 2012-05-25 08:48:59.720
!MESSAGE Problems occurred when invoking code from plug-in: "org.eclipse.core.resources".
!STACK 0
java.lang.NullPointerException
 at org.jboss.ide.eclipse.as.classpath.core.ejb3.EJB3ClasspathContainer.getClasspathEntries(EJB3ClasspathContainer.java:116)

Afin de récupérer le stacktrace d'eclipse, rendez vous dans le dossier Workspace -> .metadata et la vous trouverez le fichier .log.

J'ai par la suite j'ai suivi les conseil d'un ami ( Kevin ) et ce tutorial proposé par Objis.

La Solution - Intégration du serveur JBoss  First :

Une fois Eclipse et SVN sont bien installés, je commence l'installation du plugin JBoss Tools.

Pour bien utilisé SVN, il faut s'assurer d'avoir télécharger le connector qui va bien avec le système. Les connecteurs sont proposés automatiquement par eclipse une fois svn est installé et qu'Eclipse est redémarré. Afin de voir les connecteurs, il suffit d'aller à Windows -> Preferences -> Team -> SVN et Visiter l'onglet SVN Client. Mon connector est Native Java HL 1.6.15:

J'accède alors à l'outil d'installation de nouveau software d'eclipse  (Help -> Install New Software) tout en spécifiant le site d'installation de JBoss Tools.

Une suite c'est fait, je passe à la configuration de mon serveur JBoss:

 Je spécifie par la suite la localisation de mon serveur JBoss (Que j'ai téléchargé et dézippé dans la racine D:\). J'ai notamment choisit la bonne version de mon Java Runtime Environment.

 Voila, dans cette fenetre je coche la case Server is externally manager.

Et le serveur est la dans la View Server:

Après toute cette manipulation, j'ai redémarrer Eclipse et par la suite j'ai importé mon code source avce SVN et la.... Ca maaaaaaaaaaaaaaaaarche, I am Happy :-). 

Installation de Java avec Erreur : Error occurred during initialization of VM

Dernierement j'ai essayé d'installer Java 1.6 et Eclipse.

Suite au téléchargement d'eclipse et en essayant de le lancer un message d'erreur est apparu:

the eclipse executable launcher was unable to locate its companion shared library

Au départ j'ai cru que c'est un probleme d'eclipse mais apres pas mal de tentations il s'est avéré que c'est le probleme de Java. En effet, en essayant la commande Java -version ou Java sur la ligne de commande, un message d'erreur s'affiche:

Error occurred during initialization of VM

java/lang/NoClassDefFoundError: java/lang/Object windows

J'ai essayé donc de modifier la valeur d'environnement (clic droite sur le poste de travail-> Propriete->Parametre Systeme Avancee -> Variables environnement)
La dans les variables système, il faut faire des modification au niveau du path, en rajoutant le chemin de dossier Java et plus précisément le JDK, mais ATTENTION, ce chemin doit être remseigné en debut et non pas à la fin:


Path= C:\Program Files\Java\jdk1.6.0_32\bin\;%SystemRoot%\system32;%SystemRoot%;%SystemRoot%\System32\Wbem;%SYSTEMROOT%\System32\WindowsPowerShell\v1.0\

Voila, suite à ses modifications, eclipse s'est à la fin lancé et tou fonctionne super bien ;-)

Maven 3 Installation

C'est quoi Maven:

Maven est un  logiciel permettant la gestion des projets. Il est basé sur le concept du Projet Object Model (POM) et permet l'automatisation des tâches récurrentes, la gestion des dépendances et la génération de rapport permettant un meilleur pilotage de projet.

Installation de Maven 3 sous ubuntu:

J'ai essayé d'installer Maven2 avec la commande :
sudo apt-get  install maven2
L'installation est terminée avec succès mais lors de lancement des commandes maven, j'ai eu des soucies avec Java. Donc j'ai décider d'installer la dernière version de Maven d'une facon manuelle.

Après récupération du packet Maven3 du site de Apache, on peut utiliser le terminal pour décompresser le dossier.
$ tar -xzvf apache-maven-3.0.4-bin.tar.gz



J'ai crée ensuite un dossier apache-maven dans usr/local/ et on copie le contenu du dossier télécharger dans cet emplacement :
$ sudo mkdir /usr/local/apache-maven
$ sudo cp -R apache-maven-3.0.4 /usr/local/apache-maven/ 

J'enchaine maintenant avec la modification des variables d'environnement en utilisant cette commande dans le terminal :

sudo gedit .bashrc

.bashrc est un fichier caché dans /home/myUser et on peut le voir dans ce dossier en utilisant Ctrl h.

Donc il faut modifier la variable PATH et rajouter les variables JAVA_HOME, M3_HOME, MAVEN_HOME et M3. Il faut vérifier que le JDK de Java est bien installé.

PATH=$PATH:/usr/local/apache-maven/apache-maven-3.0.4/bin"
JAVA_HOME="/usr/lib/jvm/java-6-sun"
M3_HOME="/usr/local/apache-maven/apache-maven-3.0.4"
MAVEN_HOME="/usr/local/apache-maven/apache-maven-3.0.4"
M3="/usr/local/apache-maven/apache-maven-3.0.4/bin"

Voila, tout est normalement bien installé. Il suffit de quitter le terminal et de le re-ouvrir. Après on peut vérifier notre installation en tapant la commande
mvn - version

Méthode Agile

Voila, lors d'une présentation d'un ami, je viens de découvrire les méthodes Agiles. J'ai essayé donc de voir de plus près ces méthodes qui ont pris pas mal de succès ces dernier temps dans le monde des entreprise.
Ces méthodes reposent essentiellement sur le respect de 5 principent qui sont :

• Adoption d'un cycle itératif et incrémental
• Implication du client dans la réalisation du produit
• Le travail collaboratif et la mise en avant de l'effort de l'équipe
• Précision des objectifs à court termes
• La livraison d'un produit fonctionnel et qui obeit aux attentes du client.

Afin de comprendre les méthodes Agiles, il faut bien comprendre quelques termes comme :

• Product Owner qui n'est autre que le client
• Scrum Meeting qui est une courte réunion quotidienne d'environ 15 minutes, permettant à l'équipe de discuter sur ce qui a été fait, les difficultés rencontrées et les objectifs du jour
• Product Backlog afin de gérer dynamiquement les fonctions du produit à réaliser ainsi que leurs priorités
• L'integration continue du produit englobant la compilation, le testing...

Scrum est une méthde Agile permettant de gérer les projet.  L'idée de base est l'utilisation d'une spécification incrémentale. Au début du projet, le Product Owner (client) liste des scénarios d'utilisation (Product Backlog) en attribuant pour chaque scénario une valeur métier donnant une idée sur son importance dans le projet.

A suivre ...