《Object-Oriented Software Engineering》 - 书摘精要

Author : Stephen R. Schach

(P4) The software must be easy to modify when the user's needs change;

(P13) The earlier we correct a fault, the better;

(P18) Instead, planning, testing and documentation should be activities that accompany all other activites while a software product is being constructed;

(P19) Accordingly, the object-oriented paradigm makes maintenance quicker and easier, and the changce of introducing a regression fault (that is, a fault inadvertently introduced into one part of a product as a consequence of making an appearantly unrelated change to another part of the product) is greatly reduced;

(P20) 

The object-oriented paradigm promote reuse; because objects are independent entities, they can be utilized in future products;

The object-oriented paradigm is the best approach available today. However, like all technologies, it is certain to be superseded by a superior technology in the future;

(P23) The word defect is a generic term that refers to a fault, failure, or error;

(P25) Software engineers shall participate in lifelong learning regarding the practice of their profession and shall promote an ethical approach to the practice of the profession;

(P33) Idealized Software Developemnt : Requirements --> Analysis --> Design --> Implementation;

(P38) Iteration is an intrinsic aspect of software engineering, and iterative life-cycle models have been used for over 30 years;

(P39) 

There are five core workflows:

1. requirements workflow;

2. analysis workflow;

3. design workflow;

4. implementation workflow;

5. test workflow;

(P44) The more robust the architecture, the more resilient to change the software will be;

(P49) Testing should proceed continually throughout the software process;

(P54) Pair programming does not always work well with shy or overbearing individuals, or with two inexperienced programmers;

(P55) 

A principle of exterme programming is to minimize the number of features; this is no need to build a product that does any more than what the client actually needs;

Working software is considered more important than detailed documentation;

(P56) 

Being able to build small-scale software products does not necessarily mean that one has the skills for building medium-scale software products;

Building large-scale software products require even more specialized and sophisticated skills than those need to cobble together small-scale software products;

(P61) 

The spiral model is applicable to only large-scale software;

Agile process for only small-scale software;

The evolution-tree model and the iterative-and-incremental model are closest to the way that software is produced in the real world;

(P69) The software development process is structured around the five workflows:

1. requirements;

2. analysis (specification);

3. design;

4. implementation;

5. testing;

(P71) RUP - Rational Unified Process;

(P72) UML is the tool that we use to represent (model) the target software product;

(P75) The analysis workflow in a more precise language that ensures that the design and implementation workflows are correctly carried out;

(P76) Another important aspect of the design workflow is choosing appropriate algorithms for each method;

(P79) Testing : unit testing --> integration testing --> product testing --> acceptance testing;

(P81) COTS Software : alpha release, beta release;

(P89) 

Capability Maturity Models :

Maturity Level 1 : Initial Level;

Maturity Level 2 : Repeatable Level;

Maturity Level 3 : Defined Level;

Maturity Level 4 : Managed Level;

Maturity Level 5 : Optimizing Level;

It is unfortunate that the vast majority of software organization all over the world are still level 1 organizations;

Although a number of organizations have attained maturity levels 2 and 3, few have reached levels 4 or 5. The two highest levels therefore are targets for the future;

(P105) The chief programmer was both a successful manager and a highly skilled programmer who designed the architecture and any critical or complex sections of the program;

(P107) Super Programmer - a programmer whose output is four or five times that of an average good programmer;

(P112) Individuals volunteer to take part in an open-source protect for two main reasons : for the sheer enjoyment of accomplishing a worthwhile task or for the learning experience;

(P138) CVS - Concurrent Versions System;

(P147) Quality is not something added afterward by the software quality assurance (SQA) group but rather must be built in by the developes from the very beginning;

(P177) 

Levels of Cohesion (Good -- > Bad):

7. Informational Cohesion;

6. Functional Cohesion;

5. Communicational Cohesion;

4. Procedural Cohesion;

3. Temporal Cohesion;

2. Logical Cohesion;

1. Coincidental Cohesion;

Lack of reusability is a serious drawback;

(P182) 

Levels of Coupling (Good --> Bad):

5. Data Coupling;

4. Stamp Coupling;

3. Control Coupling;

2. Common Coupling;

1. Content Coupling;

(P208) Why has the classical paradigm had so much success? This can be explained by realizing that the classical paradigm was adopted at a time when software engineering was not widely practiced;

(P224) Pattern - Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice;

(P225) Patterns can interact with other patterns;

(P226) Architecture patterns are another way of achieving architectural reuse. One popular architecture pattern is the model-view-controller (MVC) architecture pattern;

(P227) 

MVC Component || Description || Corresponds to

-----------------------------------------------

Model || Core functionality, data || Processing

View || Displays information || Output

Controller || Handles user input || Input

-----------------------------------------------

(P227) Another popular architectural pattern is the three-tier architecture;

(P235) 

Creational design patterns slove design problems by creating objects;

Structural design patterns solve design problems by identifying a simple way to realize relationships between entities;

Behavioral design patterns solve design problems by identifying common communication patterns between objects;

(P237) 

[Creational Patterns]

1. Abstract Factory - Creates an instance of several families of classes;

2. Builder - Allows the same construction process to create different representations;

3. Factory Method - Creates an instance of several possibile derived classes;

4. Prototype - A class to be cloned;

5. Singleton - Restricts instantiation of a class to a single instance;

[Structural Patterns]

6. Adapter - Matches interfaces of deifferent classes;

7. Bridge - Decouples an abstraction from its implementation;

8. Composite - A class that is a composition of similar classes;

9. Decorator - Allows additional behavior to be dynamically added to a class;

10. Facade - A single class that provides a simplified interface;

11. Flyweigh - Uses sharing to support large numbers of line-grained classes efficiently;

12. Proxy - A class functioning as an interface;

[Behavioral Patterns]

13. Chain-of-Responsibility - A way of processing a request by a chain of classes;

14. Command - Encapsulates an action within a class;

15. Interpreter - A way to implement specialized language elements;

16. Iterator - Sequentially access the elements of a collection;

17. Mediator - Provides a unified interface to a set of interfaces;

18. Memento - Captures and restores an object's internal state;

19. Observer - Allows the observation of the state of an object at run time;

20. State - Allows an object to partially change its type ar run time;

21. Strategy - Allows an algorithm to be dynamically selected at run time;

22. Template Method - Defers implementations of an algorithm to its subclass;

23. Visitor - Add new operations to a class without changing it;

(P238) To obtain maximal benefit from design patterns, multiple interacting patterns are employed;

(P256) Careful planning at the beginning of the project perhaps is the single most important factor that distinguishes success from failure;

(P341) A useful rule of thumb is that abstract nouns rarely end up corresponding to classes. Instead, they frequently are attributes of classes;

(P403) It is easier to implement a number of smaller subsystems than one large system;

(P449) 

Acceptance testing naturally includes correctness testing, but in addition, it is necessary to test performance and robustness;

Test four major components of acceptance testing - testing correctness, robustness, performance and documentation;