Software Engineering Summary

Feasibility Study (cont.)

Technical feasibility

Operational feasibility

Economic viability

RUP Four phases: initial, refinement, build, handover

(1) What is the life cycle of software. The life cycle can be summarized into several processes. For software engineering, the concept of life cycle is very important. Waterfall and rapid prototyping the main differences between the two software engineering model life cycles.

(2) Waterfall and rapid prototyping two models are suitable for the development of which software systems. Why. Please give an example according to your knowledge or practice.

Requirement analysis is an important stage of software survival, and it is the foundation of the success of software development projects.

The purpose of demand analysis is to ensure the integrity and consistency of requirements.

Requirements Engineering: The process of understanding, analyzing, documenting, and verifying the services and constraints that the system should provide

Three types of software requirements: Functional requirements Non-functional requirements design constraints

SA uses the concept of abstract model, according to the software internal data transfer, transformation of the relationship between the top-down function decomposition of the system analysis method to define the requirements of the system.

DD is an organized list of all system-related data elements, along with precise, rigorous definitions that allow users and system analysts to have a common understanding of inputs, outputs, storage components, and intermediate computations.

DD is a collection of information about the data, that is, a collection of definitions of all the elements contained in the flow diagram.

Use cases can be used in almost any situation, using use cases to capture user requirements and plan and control projects.

The acquisition of use cases is one of the main tasks of the requirements analysis phase, and is the first task to be done.

A use case model consists of several use case diagrams. The work of creating a use case model includes defining the system, looking for actors and use cases, describing use cases, defining relationships between use cases, and confirming models.

OOA is the process of extracting and collating user requirements and establishing an accurate model of the problem domain.

The object model of a large, complex system is usually composed of the following 5 levels: The subject layer, the class and object layer, the structure layer, the attribute layer, and the service layer.

Design principle:

Modularity, abstraction, gradual refinement, information hiding and localization, module independence

From the technical point of view, the traditional structured method divides the software design into 4 parts: architecture design, data design, interface design and process design.

Structural design: Defines the relationship between the main components of a software system.

Data design: Transforms the objects and relationships described in the entity – diagram, and the detailed data content described in the data dictionary into the definition of data structures.

Interface design: Inter-component within the software, between software and other collaborative systems, and between the software and the user interaction mechanism.

Process design: Transform the structure into a procedural description of the software.

Why modularity.

Modularity is designed to enable a complex large program to be managed by human intelligence.

If a large program consists of only one module, it will be difficult to understand.

The role of modularity:

Using the modular principle can make the software structure clear, not only easy to design and easy to read and understand.

Modularity makes the software easy to test and debug, thus helping to improve the reliability of the software.

Modularity can improve the software's modifiable nature.

Modularity also contributes to the organization and management of software development projects.

The following design principles should be adopted:

Use data coupling as much as possible,

Less control coupling and feature coupling,

Limiting the scope of the public environment coupling,
No content coupling at all.

HMI Design:

Three "golden rules":

The user is under control.

Reduce user memory burden.

Keep the interface consistent.

HMI Design Guide General Interaction Guide Information Display Guide data entry Guide

Guidelines for object-oriented design

1. Modular

The object is the module. It is a module that combines the data structure and the methods of manipulating these data together.

2. Abstraction

Object-oriented methods not only support process abstraction, but also support data abstraction.

3. Information hiding

In the object-oriented approach, information hiding is implemented through the encapsulation of objects.

4. Weak coupling

Coupling refers to the degree of correlation between different objects.

5. Strong cohesion

6. Reusable

Reuse is basically the beginning of the design phase.

Reuse is also called re-use or reuse, refers to the same thing without modification or a little change on repeated use.

Broadly speaking, software reuse can be divided into the following 3 levels:

Knowledge reuse (software engineering knowledge reuse).

Reuse of methods and standards (object-oriented approaches or the reuse of nationally developed software development specifications).

Reuse of software components.

2. Level of reuse of software components

Code reuse: Calling modules in a library

Source Code Clipping

The source code contains #include

Inherited

Reuse of design results: Reuse the design model of a software system. This level of reuse helps to migrate an application system to a completely different hardware and software platform.

Analysis result reuse: Reuse the analytic model of a system. This reuse is especially useful when the user needs have not changed, but the system architecture has changed radically.

The "Class" in object-oriented technology is an ideal reusable soft component, which is called a class component.

1. Features of reusable soft components

Module independence is strong: With a single, complete function, and repeated testing is confirmed to be correct.

Highly malleable: it is necessary to provide a mechanism for expanding or modifying existing components to suit specific needs, which is very simple and convenient to use.

The interface is clear, concise and reliable: detailed documentation.

2. How to reuse class artifacts

Instance Reuse (encapsulation)

Create an instance of the class as needed, using the appropriate constructor.

Create a more complex class with a few simple objects as members of the class.

Inheritance Reuse (inheritance)

Inheritance reuse provides a means to safely modify existing class artifacts for reuse in the current system.

Polymorphic Reuse (polymorphism)

Makes the external interface of the object more generalized, reducing the complexity of the message connection.

The object-oriented design model of most systems is logically composed of 4 major parts.

Problem Domain Subsystem

Human-Computer Interaction Subsystem

Task Management Subsystem

Data Management Subsystem

Opening and closing principle: a software entity should be open to the extension and closed for modification;

Interface-oriented programming is advocated in design mode, and implementation-oriented programming is not advocated.

There are two common reuse techniques in design patterns, namely, class inheritance and object composition, precedence object combination rather than class inheritance

The whole design pattern runs through one principle: the face of interface programming, not the face of implementation. The objective principle is: to reduce coupling and enhance flexibility.

It is usually a unit test after each module is written.

At the end of this phase, the software system should be tested in a variety of ways, usually by a dedicated tester.

1. Documentation inside the program

An appropriate identifier

A name with a distinct meaning

The abbreviation rules are consistent, and each name is annotated

appropriate annotations

Introductory annotations at the beginning of each module

Annotations related to a section of program code

Visual organization of the program

Ladder form

The efficiency of the program refers to the execution speed of the program and the memory storage space that the program needs to occupy.

Software Testing Guidelines

All tests should be traceable to the user's needs

The most serious errors are those that cause the program to fail to meet the user's needs

A test plan should be developed before the test begins.

A test plan can be developed by completing the requirements model

Applying the Pareto principle to software testing

80% of errors found in the test are probably caused by 20% of the modules in the program

Should start with a "small scale" test and step into a "large scale" test

Single Program module integrated module cluster entire system

The exhaustive test is impossible.

The test can only prove that there are errors in the program and that there are no errors in the program

In order to achieve the best test results, independent third parties should be engaged in the testing work

Software engineers developing software are not the best candidates to complete all the testing work

Unit test test Focus

Module interface

Local data structure

Important Execution Pathways

Error handling path

Boundary conditions

The test data and the expected output result are called test cases.

Software reliability:

The probability of a program running successfully within a given time interval, as specified in the specification.

Availability of software:

Program at a given point in time, according to specifications, the probability of successful operation.