Feature-driven development

Feature-driven development
See also

Feature-Driven Development (FDD) - is one of the methods of adaptive project management. It pays for quick delivery of visible work results and accurate information on the current state of the project with minimal involvement of programmers. FDD combines the best practices of managing IT projects into a coherent whole. The recommendations included in the methodology are characterized by focusing on the functionality of the application valued by the client. The FDD methodology also describes individual project participants, their roles, subsequent software development processes and methods of measuring results. The creators of the approach are Jeff De Luca and Peter Coad, who, working together on a large programming undertaking in Singapore, were forced to develop a more effective than traditional project management method. The term "Feature-Driven Development" appeared for the first time in the book "Java Modeling in Color with UML" by Peter Coad in 1999.

5 processes of Feature-Driven Development

  • The first process - developing a general model: The FDD model assumes that teams will make enough effort at the beginning of the project to build an object model that emphasizes the domain problem. FDD modeling is time-limited and largely based on collaboration. Domain models should be created by small groups and then presented for evaluation. It should be assumed that the proposed model or combination of models will be used for each domain area. Then they will be merged to create a generic model.
  • The second process - creating a list of functions. From the knowledge obtained during the modeling process, a list of functions is determined by dividing domains into thematic areas that contain information about business activities. The steps that are used for each business activity are a categorized list of functions. Functions are expressed, for example, as: result, action, object. It is required that the completion of the function does not last longer than two weeks. If it is impossible then you should divide these functions into smaller sections,
  • Third process - plan by function. After the function lists have been created, the following process involves assigning different sets of functions to programmers.
  • The fourth process - design by function. Programmers together with the main programmer create a design package for each function by selecting a function group that should be created within two weeks. The main programmer also creates detailed diagrams for each function, while improving the model. After this stage, prologues are created and project control is carried out.

The fifth process - build by function. After the project inspection is completed, the designers plan the operation for each function and develop the code for the respective classes. The next step after completing the control and performing the unit test is adding the function to the main version.

Good FDD practices

Feature-Driven Development includes a number of good practices supporting the management of an IT project. The most important of them are:

  • The object model of the system

In the FDD approach, it is very important to determine the general object model of the designed system. Based on it, all subsequent product decisions are made. The way of presenting the developed model is also important. For this purpose, it is recommended to use color UML modeling, as the FDD approach was based on this technology.

  • Create based on requirements

Specific functionalities provided at a specific time are essential for the customer. For this reason, it is necessary to ensure the creation of an exact list of required functions. All of them that are impossible to implement in a two-week period are broken down into other, smaller ones.

  • Responsibility for the code

It is implemented by assigning each class resulting from the application project to a specific programmer who is fully responsible for it from a given moment.

  • Dynamic teams of programmers

If a given functionality requires more classes, the team responsible for the whole element is assembled. The team consists of programmers, each of whom develops a given class. One of them is the main programmer, whose task is also to coordinate the activities of the entire team. In the FDD approach, there is often a situation in which one programmer belongs to many teams.

  • inspections

Regular inspections are carried out to ensure quality control and code integrity. Due to the fact that each programmer belongs to many teams, the inspection does not evaluate the employees, but the entire functionality and the way they are performed.

  • Incremental product construction

At regular intervals, all code that performs specific functions is downloaded and all work necessary to run it is performed. This provides the opportunity to conduct tests and present the subsequent versions of the system to the client.

  • Configuration management

In addition to storing only the source code of the project, it is also recommended to pay attention to all events affecting its final form. Such noteworthy events are, for example, changes in requirements, results of analyzes, errors detected.

  • Reporting progress

At all levels of product creation, data about its current status and changes are collected. This information is then used to create summary reports, supporting project managers.

  • Feature-Driven Development and other agile methodologies

All adaptive methodologies have certain areas in which they are very similar to each other. The most-known of them, such as Extreme Programming or Scrum, as well as Feature-Driven Development, are based on an incremental approach to software production. These methodologies focus on providing the client with running versions of the program as quickly as possible and communication between people participating in the project. However, the method of achieving these goals is different for each methodology.

Differences start at the system design stage. Extreme Programming recommends software development based only on functional requirements analysis, implementing each set of functions in turn. Feature-Driven Development advises on the other hand to create a general object model of the product being created. This approach extends the time of the preparation phase, but has its advantages. Creating a general model before starting work allows you to reduce later changes in the code and easier project management. Another distinguishing feature of FDD compared to other methodologies is the approach to programming and responsibility for the code. In FDD, specific developers are responsible for the classes assigned to them, and the quality of the code is maintained by means of periodic inspections. In the extreme programming methodology, however, programming in pairs is recommended as a method of code inspection. FDD, unlike other adaptive methodologies, does not put much emphasis on testing. The method and accuracy of their implementation depends on the main programmer. Other agile methodologies approach this problem much more accurately by requiring writing tests for a given functionality before creating it, which ensures a high degree of code reliability.

References