Development process and mapping design to code

Development process

A development process is the set of ordered activities to build software. In OOAD we use the iterative Unified Process (UP), with four phases and the disciplines run in every iteration:

 Inception -> Elaboration -> Construction -> Transition
   (idea,      (core arch,    (build the       (deploy,
    scope)      main risks)    rest)            train)
 each phase: several iterations of
   Requirements -> Analysis -> Design -> Code -> Test

Example (Population Information System): Inception - scope is to display population data; Elaboration - use cases "View Data" and "Login" are analysed, classes and architecture chosen; Construction - the Admin data entry and graphs are built over iterations; Transition - system is installed in the Ministry.

Mapping design into code

The design models (use case, collaboration, class diagram) map to code as follows:

1. Each class in the design -> a class.
2. Attributes -> private fields; operations -> methods.
3. Associations -> reference fields or collections.
4. Messages in the collaboration diagram -> method calls in the bodies of methods.
5. Use cases -> controller methods/events.

Use case diagram: actors User and Admin; use cases View Population, Visualize, Login, Enter Data. Collaboration diagram: 1: viewPopulation(place) from :User to :DataController, 2: query(place) to :Database, 3: render(data) to :ChartView.

import java.util.*;

class Database {                                   // stores monthly data
    private Map<String,Integer> population = new HashMap<>();
    public void save(String place, int count) { population.put(place, count); }
    public int query(String place) { return population.getOrDefault(place, 0); }
}

class ChartView {
    public void render(String place, int count) {
        System.out.println(place + " : " + count);  // chart/table
    }
}

class DataController {                             // use case controller
    private Database db; private ChartView view;
    public DataController(Database db, ChartView view) { this.db = db; this.view = view; }
    public void viewPopulation(String place) {     // msg 1
        int c = db.query(place);                   // msg 2
        view.render(place, c);                     // msg 3
    }
    public void enterData(String place, int count) { db.save(place, count); }
}

class Admin {                                      // actor class
    private String id, password;
    public Admin(String id, String pw) { this.id = id; this.password = pw; }
    public boolean login(String i, String p) { return id.equals(i) && password.equals(p); }
}

class User {
    public void viewPopulation(DataController c, String place) { c.viewPopulation(place); }
}

public class Main {
    public static void main(String[] args) {
        Database db = new Database();
        DataController ctrl = new DataController(db, new ChartView());
        Admin admin = new Admin("admin", "1234");
        if (admin.login("admin", "1234")) ctrl.enterData("Kathmandu", 1000000);
        new User().viewPopulation(ctrl, "Kathmandu");
    }
}

The use case diagram gave the actor classes and controller methods, the collaboration diagram gave the order of calls in viewPopulation, and the class diagram gave the fields and associations.