Design Process and Scope in Mobile Client team

Architecture

Executor: architect/developer

Process: 

1.       Draft architecture;

(sketch maps)

2.       Trigger architecture brainstorm;

(4+devs, 4+hours)

3.       Design architecture;

(subsystem/component diagrams, data/control flow diagrams, hierarchy/layout diagrams)

4.       Drive architecture inspection;

a)         Drive architecture review;

(5+devs, 4+hours)

b)        Update architecture;

(standard architecture documents, subsystem/component/module diagrams, data/control flow diagrams, hierarchy/layout diagrams, source code hierarchy, and etc.)

c)         Drive architecture review again;  (optional or repeating in c & d)

(5+devs include 1+devleaders, 4+hours)

d)        Modify architecture;

(standard architecture documents, subsystem/component/module diagrams, data/control flow diagrams, hierarchy/layout diagrams, source code hierarchy,  and etc.)

5.       Deliver Architecture;

(standard architecture documents, subsystem/component/module diagrams, data/control flow diagrams, hierarchy/layout diagrams, source code hierarchy,  and etc.)

6.       Deliver framework design;

(follow design process from step 3 to step 6)

7.       Modulate architecture;

(standard architecture documents, subsystem/component/module diagrams, data/control flow diagrams, hierarchy/layout diagrams, source code hierarchy,  and etc.)

8.       Drive postmortem of architecture.

(5+devs, 4+hours)

 

 

Target/Goal:  (Meet appropriate goal based on situation of the time.)

1.       Realizable functionality;

Can realize the features of current project and features in plan.

2.       Good modularity;

Pluggable traits on source code files/binary files/running progress.

3.       Good performance;

Care memory, power, CPU cycle, and footprint.

4.       Good extensibility;

5.       Good compatibility;

Between core components/modules.

6.       Good reusability;

On source code/binary/subsystem layers.

7.       Good security;

8.       Good simplicity;

Easy to understand;

Avoid over design.

9.       Good reliability;

Data integrity in data base;

Avoid data lose.

10.   Easy maintainability;

OO design principle;

Open/Close feature by configuration;

Adjust parameters of running time by configuration.

11.   Partial portability.

 

Scope: (item 1-4 are mandatory for architecture documents, item 5-16 can be added into documents gradually)

1.       Split and define subsystems;

2.       Split and define components;

3.       Split and define modules;

4.       Design main framework(Compute + I/O);

A.        Describe applied architecture styles;

B.        Describe applied application framework;

C.        Define main computation model;

D.        Define main input/output model;

E.         Make certain main thread model;

F.         Make certain main/nested loop points;  (message loop/scheduler)

G.        Make certain critical block/non-block points;

H.        Make certain critical synchrony/asynchrony points;

I.          Make certain critical buffer/queue points;

J.          Make certain main data repository/share/access control;

K.         Make certain main IPC mechanism/protocol;

L.         Make certain main pluggable subsystems/components/modules.

5.       Define error level and error code range;

6.       Define setup/running log criterion;

7.       Define source code hierarchy;

8.       Define character set criterion;

9.       Involve install and uninstall;

10.   Involve backup and restore;

11.   Involve upgrade of version and patch;

12.   Involve security/access control;

13.   Involve configuration option in compilation layer;

14.   Involve configuration option in running layer;

15.   Set requirements for partial subsystems/components/modules.

16.   Recommend design patterns for partial modules;

17.   Illuminate restrictions of current architecture.

 

 

Requirements:

1.         Deliver standard architecture documents;

2.         Deliver standard architecture diagrams;

3.         Deliver comparison in architecture documents.

 

 

Design

Executor: developer

Process: 

1.       Draft design;

(component diagrams, data/control flow diagrams, layout diagrams)

2.       Drive design inspection;

a)         Drive design review;

(4+devs include 1+architects, 2+hours)

b)        Update design;

(standard design documents, component/module diagrams, class/interface diagrams, sequence diagrams, and etc.)

c)         Drive design review again;  (optional or repeating in c & d)

(4+devs include 1+architects, 4+hours)

d)        Modify design;

(standard design documents, component/module diagrams, class/interface diagrams, sequence diagrams, and etc.)

3.       Deliver Design;

(standard design documents, component/module diagrams, class/interface diagrams, sequence diagrams, and etc.)

4.       Modulate design;

(standard design documents, component/module diagrams, class/interface diagrams, sequence diagrams, and etc.)

5.       Drive postmortem of design.

(4+devs, 4+hours)

 

 

Target/Goal:  (Meet appropriate goal based on situation of the time.)

1.       Realizable functionality;

2.       Good modularity;

3.       Good performance;

4.       Good extensibility;

5.       Good compatibility;

6.       Good reusability;

7.       Good security;

8.       Good simplicity;

9.       Good reliability;

10.   Easy maintainability;

11.   Partial portability.

 

 

Scope:

1.       Split and define components;

2.       Split and define modules;

3.       Define main classes;

4.       Define outward interfaces;

5.       Define inward interfaces;

6.       Describe applied design patterns;

7.       Describe specific algorithm;

 

 

Requirements:

1.         Deliver standard design documents;

2.         Deliver standard design diagrams;

3.         Deliver comparison in design documents.

 

 

Re-architecture/Re-design

Executor: architect/developer

1.       Follow architecture/design process;

2.       Illustrate the advantage of new one comparing with old one.