Agile Modeling in Software Projects

Recently Jeff Sutherland mentioned another certification for software programmers since Scrum does not include software engineer techniques but very present in XP (extreme programming) management. That is probably the reason why many software developers work with Scrum and XP methodologies together.

However although XP is very software-programming oriented it is still not enough to have a good software design in large systems projects. Additionally in many organizations it is very difficult to find a product owner that fully understand the business rules and can manage the software functionalities.

In order to efficiently use Scrum, there must be someone responsible for understanding the business. If there is no product owner, one employee must be chosen to study and logically model the business. That is exactly why a good business modeling is imperative before any large software development.

Good software design and business understanding prevents or reduces significantly re-work tasks. It is considered wasted work since these tasks do not devliver anything useful to the client and often happens when developers did not captured well the business rules.

Thus the following software development process is proposed to match DDD and agile approach. In this software process, there can be product owners, developers and scrum masters just like original Scrum the difference is that before the sprints (see Scrum reference) can start, a long DDD session is necessary in order to produce a good business model.

Briefly describing the following steps should be taken:

1. A selected person assumes the role of Product Owner
2. Product Owner becomes responsible for studying and building a business model
   
3. Product Owner writes all the system features using User Stories (from XP)
4. Product Owner schedules a Planning Meeting with the Scrum Master and Developers to present User Stories and the Business Model
5. Scrum Master schedules a Sprint Meeting with developers to plan the Next Sprint based on the Stories
6. Developers begin the Sprint (from 1 to 2 weeks)
7. Scrum Master Organizes Daily Meetings with Developers (just like Scrum)
8. At the end of the Spring, Scrum Master schedules a Weekly Meeting to present the system to the Product Owner but it also includes the developers of the project who makes considerations about the system presented
9. Scrum Master organized a Retrospective Meeting with the developers to discuss what went wrong or right with the Sprint and then they start planning the next Sprint.
10. Go to Step 6 until Product Owner gets satisfied
    

How the repository pattern works ?

The classes that represent the elements of a domain must contain all the business logic inside it such as tax calculation, name validation, etc. However in many circumstances it is also necessary to access data in order to complete the business logic inside these classes.

Take the example below:

Suppose I want to create an instance from the Client class and that clients must have a name and an address (there may be more information but lets stay with those two data for simplification purposes).
So, this could be instantiated like: (C# code)

// Open database connection (and Begin Transaction)
SessionManager.Open( );
: : :
// Parameters are: name, zipcode, adress number, address complement, country
Client client = new Client(“New Client”,”12500”,12,“Room 14”,Country.US);
: : :
// Close database connection (and Commit Transaction)
SessionManager.Close( );

Although simple, the line above hides many steps such as:

• Check if client name is valid

• Check if zipcode exists in the county US

• Check if address number is correct

• Check if addres complement id correct

• Check if there are clients with the same name and address

• Proceed with the client creation

However in order to complete some of this steps, the Client object should be able to access the data layer and that is the responsibility of the repositories. According to Martin Fowler's website: Mediates between the domain and data mapping layers using a collection-like interface for accessing domain objects.
Reference: http://www.martinfowler.com/eaaCatalog/repository.html

In order to make it possible the code line above, an Address and Client class must be implemented.

See full code listing below:

// Address is a value object used by Client class
public class Address
{
     public Address(string zipCodeNumber,int number,string addrComplement)
     {
            // Check if zipcode number exists in the country  (ZipCode Repository uses SessionManager inside it)
            IZipCodeRepository zipCodeRepository = RepositoryManager.GetRepository( );
            ZipCode zipCode = zipCodeRepository.Get(zipCodeNumber,country);
            if (zipCode == null) { throw new NonExistentZipCodeException(zipCodeNumber,country);
            // Check if address number is correct
            if  (number <= 0) { throw new InvalidAddressNumberException(number); }               
            // Check if address complement is correct
            if (complement.Trim( ) == string.Empty) { throw new  InvalidAddressComplementException(addrComplement)); }
            // Sets values
       this._zipCode = zipCode;
       this._number = number;
            this._complement = complement;
     }
     private ZipCode _zipCode = null;
     public ZipCode ZipCode get { return _zipCode; }
     private int _number = 0;
     public int Number { get { return _number; } }
     private string _complement = string.Empty;
     public string Complement { get { return _complement; } }
}

// Now the Client class
public class Client
{
     private long _id;
     public long Id { get { return id; } set { this.id = value; } }
     private string _name = string.Empty;
     public Name
     {        
            get { return _name; }  
            // Check if name is valid    
            set
            {
                   if (name.Trim( ) == string.Empty) { throw new InvalidNameException(); }               
                   // Check if there are Clients with same name and address               
                   IClientRepository clientRepository = RepositoryManager.GetRepository();
                   bool exists = clientRepository.ClientExists(name,zipCodeNumber,number,addrComplement,country);
                   if (exists) { throw new ClientExistsException( ); }
                   this._name = value;         
                
             }
     }
     private Address _address;
     public Address { get { return _address; } }
     public Client(string name,string zipCodeNumber,int number,string addrComplement,Country country)
     {       
             // Creates a Client
             this.Address = new Address(zipCodeNumber,number,addrComplement,country);
             this.Name = name;     
      }
}

Repositories have at least two advantages:

• It removes data specific code from the domain classes which are concerned only about business logic

• It allows unit tests since repositories are referred as interfaces in domain classes and thus fake repositories can be created without depend on database connection