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;
转载于:https://blog.51cto.com/tianjing/907633