《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;

你可能感兴趣的:(software)