Harbin Institute of Technology's "Introduction to Software Engineering" Review Guide

Review Guide for Introduction to Software Engineering Major of Harbin Institute of Technology

Preface

Students in elective courses only need to master the first 5 chapters and the introductory part for review. Students majoring in software engineering need to master all the content, but they are usually given a lot, so they can cope with the exam with a little review. The parts that the author thinks need to be remembered according to his personal understanding are marked in bold. The unmarked parts are only for understanding, but it is best to understand them.

The content of this article is based on the author's personal understanding. If there is any inaccuracy, please point it out. I will continue to enrich the content of the article and make it a good review guide.

In addition to coping with exams, the author also hopes that students majoring in software engineering will have a general understanding of software engineering and that learning is not just for exams. In fact, software is more important to current life. All walks of life need software. A person who does not understand computers at all can also achieve the desired purpose through the use of software.

Introduction—Introduction to the Software Engineering Major Introduction Course

Software Engineering : A discipline that studies or applies engineering methods to design, create, build, and maintain effective, practical, and high-quality software.

The development of software engineering major in China : In the early 1980s , China began to explore software engineering education, and some universities opened software engineering graduate courses. In 1984 , a graduate class in software engineering was held. In 1998 , the Ministry of Education approved the software engineering major to be included in the catalog of undergraduate majors . In 2001 , the Ministry of Education approved the establishment of a model software college and developed undergraduate and graduate software engineering education programs. In 2006, the Ministry of Education established the Teaching Guidance Subcommittee for Software Engineering Major in Colleges and Universities. In 2011 , a first-level doctoral program in software engineering was established . In 2020 , build a characteristic and exemplary software college . These indicate that my country's software engineering education is gradually maturing.

Chapter 1 Preliminary understanding of software engineering major

Main research contents of software engineering : software development process , software development methods , software engineering management and support , software quality assurance , software engineering measurement , computer-aided software engineering environment and tools, etc.

A framework for software engineering : goals, processes, and principles

Elements of Software Engineering : Methods, Tools, and Processes

Software crisis : In the late 1960s, as the scale of software and the difficulty of development increased, software development cycles were long, costs were high, quality was poor, and maintenance was difficult, leading to a software crisis. Problem: The estimation of software development workload and cost is inaccurate; the software development progress is difficult to control; the quality and reliability of software products are unsatisfactory.

The emergence of software engineering : In October 1968, the North Atlantic Treaty Organization NATO held a computer science conference. Fritz Bauer first proposed the concept of "software engineering" and the strategy to overcome the "software crisis", emphasizing the organization of software development work according to engineering principles and methods. The field of software engineering technology emerged from this.

Development history of software engineering methods : 1960's-1970's: Structured method 1980's: Object-oriented method 1990's: Component-based method and Web Services 2000's: Service-oriented SOA method and agile software development method 2010's: Internet-based and cloud-native software development method 2020's: Intelligent software development methods for the Metaverse

Several stages of software engineering : requirements engineering, software design, software development, software testing and delivery

1960s-1970s: Structured approach

Methods: Structured programming method, waterfall model, spiral model, etc.

Programming language: Fortran language, Pascal language, C language. The structured method is like building a bungalow or using the technology of building a bungalow to build a complex building.

1980s: Object-oriented approach

Methods: object-oriented methods, object-oriented models and modeling tools, etc.

Programming languages: C++ (83), Java (95), Visual series languages ​​(90), etc.

The object-oriented approach is like building a tall building, making it easier to build complex buildings

1990s: Component-based approach

Methods: software component methods, Web Services, software reuse methods, etc.

Programming language: Visual series languages, Windows operating system, etc.

Component-based methods, such as stacking wood and making prefabricated parts, can build more complex buildings in batches and quickly.

2000s: Service-Oriented Architecture SOA approach

Software development methods based on Internet and cloud computing

Main development trends of software engineering technology:

New software architecture and development methods - software architecture based on cloud computing platform, model-driven development method MDA, agile software development methods, software integrated development environment and tools

Software componentization - Software Component technology, component-based software reuse (Software Reuse)

Software service-oriented architecture SOA, Web Services, software as a service SaaS, software service engineering

Software requirements engineering (Requirement Engineering) - knowledge-based software requirements analysis and requirements analysis automation

Middleware - middleware platform, enterprise service bus ESB, network components, middleware-based software integration technology

Software quality assurance - software quality evaluation and measurement, software reliability technology, software process improvement model

Software domainization - domain software engineering (Domain Engineering), industry application software, enterprise application software

The development history of software engineering:

Stage 1: Independent Programming Service

1950s-1960s: Machine-centric, professional services companies such as IBM

Stage 2: Software Product

1960s-1970s: The software industry develops independently, with software product companies such as ADR

Stage 3: Enterprise Solution

1970s-1980s: Application-centric, enterprise solutions company, SAP, Oracle

Phase 4: Packaged Software for Mass

1980s-1994: Individual-centered, popular software companies, Microsoft, Apple

Stage 5: Internet-Based Software and Service

1990s, network-centric, Internet companies, Netscape, Yahoo, Google

2000s, society-centered, service company, Facebook, Twitter, YouTube

The emergence of the software engineering discipline:

In August 2004, after years of hard work, more than 500 experts and professors from universities, scientific research institutions and businesses around the world launched the final version of the two documents, Software Engineering Knowledge System and Software Engineering Education Knowledge System (SEEK), marking As the discipline of software engineering was formally established around the world, it became an independent discipline in the field of computing, and it also developed rapidly at the undergraduate education level.

The development of software engineering disciplines in China:

In the early 1980s, my country began to explore software engineering education, and some universities took the lead in offering software engineering courses. In 1984 and 1985, Peking University and Fudan University held graduate classes in software engineering. In 1998, the Ministry of Education approved the software engineering major to be included in the catalog of undergraduate majors. In 2001, the Ministry of Education approved the establishment of a model software college and developed undergraduate and graduate software engineering education programs. In 2006, the Ministry of Education established the Teaching Guidance Subcommittee for Software Engineering Major in Colleges and Universities. These measures have effectively promoted the development of my country's software engineering discipline and marked the beginning of the maturity of my country's software engineering education.

In 1998, the Ministry of Education promulgated the "Catalogue of Undergraduate Majors in General Colleges and Universities (Promulgated in 1998)", and the software engineering major officially appeared in the catalog, with the professional code 080611W.

In 2001, the Ministry of Education and the State Planning Commission approved the establishment of 35 "demonstration software colleges" (later added 2) to cultivate high-level, practical, complex, and internationally competitive software engineering talents, and developed undergraduate Undergraduate and graduate software engineering education programs. There are now more than 400 colleges and universities across the country offering software engineering majors.

In 2006, the Ministry of Education established the Teaching Guidance Subcommittee for Software Engineering Major in Colleges and Universities. In 2013, the establishment of an independent “Ministry of Education Software Engineering Major Teaching Steering Committee” was approved.

In 2011, the Academic Degrees Committee of the State Council approved the addition of doctoral and master's degree programs in the first-level discipline of "Software Engineering". There are now more than 100 universities offering doctoral/master's degree programs in software engineering.

In 2020, the Ministry of Education approved the establishment of 33 "characteristic demonstration software colleges" to explore the integration of industry and education training paths for software talents with Chinese characteristics, and to cultivate distinctive software talents that meet the needs of industrial development.

Software Engineering Knowledge System (SWEBOK V3.0) Software Requirements Software Design Software Construction Software Testing Software Maintenance Software Configuration Management Software Engineering Management Software Engineering Models and Methods Software Engineering Process Software Quality Software Engineering Economics Software Engineering Professional Practice Computing Fundamentals Engineering Fundamentals Mathematics Fundamentals

Software engineering science and technology categories : Software Process (Software Process) Software Development Method (Software Development Method) Software Requirement Engineering (Software Requirement Engineering) Software Architecture (Software Architecture) Software Development Tools and Environment (Software Development Environment) Software Reuse and Software Component (Software Reuse & Component) Software Middleware (Software Testing) Software Maintenance (Software Maintenance)

Basic thinking model of software engineering discipline

Computational thinking - the study of symbolic, computational and automated software to solve social/natural problems. Expressing social/natural problems with symbols, performing calculations based on symbols, and implementing calculations with software are the basic thinking patterns for solving social/natural problems.

Software and program thinking: combination-abstraction-construction-recursion

"Program" is constructed from basic action instructions, a combination of several instructions or an execution sequence to implement complex actions. The essence of program is combination, abstraction and construction. The basic means of construction are iteration and recursion. Recursion is a method of expressing repetitive and infinite construction of similar objects and actions.

Chapter 2 Software Architecture and Life Cycle

Software Architecture : The basic organization of a system, including each component, the relationship between components and the environment, and the principles that guide its design and evolution.

Software architecture = components + connectors + constraints

Component: A reusable software structural unit with a certain function, representing the main computing elements and data storage in the system. Component is an abstract concept. In a program, it can refer to program functions, modules, objects, classes, etc.

Connector: represents the interaction between components and realizes the connection between components.

Constraint: refers to the standards or requirements according to which components in the software architecture are connected, involving performance constraints or functional constraints of the system.

Software architectural styles are idiomatic paradigms that describe the way a particular system is organized, emphasizing common organizational structures among software systems. A software architectural style defines a set of symbols for component and connector types and a set of constraints for their combinations.

Typical software architecture style :

Call/Return architectural style

Main/subroutine architecture: Divides functionality into a control hierarchy.

Remote procedure call architecture: The components in it are distributed at different nodes of the network.

Object-Oriented architectural style

A system is viewed as a collection of objects; system components are individual objects, each with its own set of functionality that encapsulates data and operations on that data. Data and its operations are encapsulated into abstract data types; components only interact with the outside world through interfaces, and communication and cooperation between components are achieved through information transfer.

Data-Centric architectural style

The data storage component is taken as the core and closely integrated with other components. Other software components access the data storage component to form a topological relationship similar to a star structure. Each client software runs independently.

Data Flow architectural style (also known as pipeline-filter style)

System tasks are divided into a number of consecutive processing steps. These steps are connected by data flows through the system. Input data is converted into output data through a series of calculations or operation components. For example, the pipe-filter pattern has a set of filter components connected by pipes, with each filter component running independently.

Hierarchical architectural style

Software systems are composed of multiple components at different levels. In the inner layer, the components complete the operation of establishing the operating system interface; in the middle layer, there are utility services and application software functions; in the outer layer, the components realize the operations of the user interface.

event driven architecture style

Event-driven is based on the current system and drives the operation of the entire system based on event declarations and development status. The basic idea is that the system's external behavior can be realized through its processing of events. Instead of calling procedures directly, the build declares events. When an event is triggered, the system will automatically call the processes of other components through the component table registered for the event.

Interpreter architecture style (virtual machine style)

As an architecture, the interpreter is mainly used to build virtual machines and fit the gap between program semantics and computer hardware. In fact, the interpreter is a virtual machine created by software. Interpreter style is also called virtual machine style.

Feedback control loop architectural style

A feedback control loop is a specific data flow structure. Traditional data flow structures are linear, while architectures that control continuous loop processes are circular.

MVC architecture architecture

Model-View-Controller MVC (Model-View-Controller) architecture

The Model-View-Controller MVC architecture divides the software system into three main types of components: Model, View, and Controller, which respectively correspond to business logic processing functions, interface presentation functions, and model manipulation. and view access and coordination functions.

The goal of software architecture design: to meet software requirements. Software requirements are the basis and driving factor of architecture design and play a key role in shaping the software architecture. Pursue high quality, scalability, scalability, easy maintenance... Architectural design provides actionable guidance for detailed design.

Software life cycle : refers to the entire process from the creation of software to its abandonment, just like the product life cycle. Generally speaking, the basic process of software engineering revolves around the software life cycle.

Several common software life cycle models : Waterfall Model, Evolutionary Model, Spiral Model

Basic software process :

Requirements engineering refers to engineering methods and techniques that use proven and effective techniques and methods to conduct requirements analysis, determine customer needs, help analysts understand the problem, and define all external characteristics of the target system.

Requirements analysis refers to the description of a software product that solves a problem in the real world and the constraints of the software product.

Software design refers to starting from the software requirements specification and based on the functions determined in the requirements analysis stage, designing the overall structure of the software system, dividing functional modules, determining the implementation algorithm of each module, and writing specific codes to form a specific design plan for the software .

Software coding is to convert the description of the detailed design process of the software into a program based on a certain computer language, that is, source program code.

Software testing is to test whether the software meets the specified functions and performance by running program code, whether there are defects and problems, and generate a software evaluation report. The purpose of testing is to discover problems in the software as early as possible and avoid defects causing accidents!

Software operation and maintenance : The process of partially or fully modifying the software product according to changes in requirements or changes in the hardware environment during the operation period after the software is delivered to the user.

Software engineering ecological environment : software engineering environment and software environment

Decomposition of software systems: When designing complex software systems, in order to reduce system complexity, it is usually necessary to decompose the software system into multiple parts or subsystems according to functions; then decompose the subsystem into several subsystems or classes; and so on. Each subsystem is relatively independent and has simple interfaces with each other.

In a software system, an object not only represents a specific thing in the problem space of the objective world, but also represents a basic element in the solution space of the software system. They are "individuals" that can be distinguished from each other.

Class is an abstraction of objects. Some objects have similar characteristics and form a "class".

A framework refers to a reusable design component, a set of abstract components and methods of interaction between components; it brings convenience to project development. Object framework makes the common content of objects of the same category into an object framework.

Component: A machine-level program file that can be released independently; an executable program file formed by encapsulating several objects and their internal relationships. Separation of interface and implementation: The interface is the communication protocol of the object or component; the implementation is the internal structural details of the object or component.

J2EE Framework: Java 2 Platform Enterprise Edition Framework

The J2EE architecture is a computing environment that uses Java technology to develop enterprise-level distributed applications; it is the de facto industry standard spearheaded by SUN. The core architecture of J2EE is extended based on the MVC framework.

Web Service Architecture

Web services are a service-oriented architecture technology. The creation and provision of services for distributed applications is achieved through standard Web protocols in order to ensure that application services on different platforms can interoperate.

Service Oriented Architecture SOA (Service Oriented Architecture): is a component model that connects different functional units of an application (called services) through well-defined interfaces and contracts between services.

Model-driven software development method (MDD: Model Driven Development): It is a software development method that uses models as the main tool for high-level abstraction. The basic idea is to allow developers to move from programming to high-level abstraction, and drive part or all of automated development by converting models into code or components.

Chapter 3 Software Requirements Engineering

Software Requirement (Software Requirement): In a clear, concise, consistent and unambiguous way, describe the user's expectations for the target software system in terms of functions, behavior, performance, cycle, cost, design constraints, etc., which is the development process Constraints on software systems during the process.

Software functional requirements (Functional Requirement): refers to the functions that the software can complete and the externally visible behaviors or effects that can be displayed in certain scenarios.

Software non-functional and quality requirements: Constraints and limitations on the system from all angles, reflecting customers' additional requirements for software system quality and performance, such as response time, data accuracy, reliability, etc.

Software development binding requirements: requirements for software development costs, delivery schedule, technology selection, compliance with standards, etc.

Software requirements engineering (Requirement Engineering) uses engineering concepts and methods to guide the practice of software requirements; it provides a series of processes, strategies, methodologies and tools to help requirements engineers enhance their understanding of business or domain issues and their environment. Obtain and analyze software requirements, guide the documentation and review of software requirements to obtain as accurate, consistent and complete software requirements as possible, and produce software artifacts related to software requirements.

Several stages of requirements engineering :

Requirements elicitation: Develop, capture and revise user requirements through communication with users, observation of existing systems and analysis of tasks

Requirements analysis: Refining, analyzing and reviewing the collected requirements to establish a conceptual analysis model for the system as seen by end users

Requirements specification description: Requirements specification is the result of requirements development

Requirement confirmation: Taking the requirement specification as input, analyze the correctness and feasibility of the requirement specification through review, simulation or rapid prototyping, discover existing errors or defects, and make timely changes and additions.

Demand management

Agile Requirements Engineering

Because the agile software development method emphasizes adapting to high-frequency demand changes, it advocates that demand descriptions should be simple and efficient.

Agile development methods do not require the use of formal requirements documents. Instead, they continuously collect user requirements, write them on cards or whiteboards as "User Story" or "Requirement Use Cases", and prioritize them according to value and urgency. Level sequencing for the next iterative development; emphasizing software delivery based on user stories.

Typical description format of user stories: As a <role>, I want <activities> in order to achieve <business value>

User stories should meet the INVEST principles: Independent, Negotiable, Valuable, Estimable, Small, and Testable.

User requirements can be flexibly changed using user stories to adapt to the development of software systems or products with strong demand uncertainty, rapid product changes, and high competitive pressure.

Software requirements elicitation : Communication between developers and users to define new systems to obtain or generate software requirements. Requirements acquisition is the prerequisite for requirements analysis. It is necessary to collect information about new systems to be developed and systems currently in use, and to extract user and system requirements from this information, combining elements such as problem solving, constraints, refinement, negotiation, and requirements specification. Together, we provide material for the next step of demand analysis.

Software requirements analysis (Requirement Analysis): Based on the preliminary software requirements obtained through requirement acquisition, further refine and analyze the software requirements, determine the priority of software requirements, establish a software requirements model, discover and solve software requirement defects, and form a high-quality software requirements model. and software requirements specifications.

Structured analysis method : A method of demand analysis oriented to data flow. The core of this analysis model is the data dictionary; there are three types of model diagrams: data flow diagram (DFD), entity-relationship diagram (ER diagram), state-transition diagram (STD), etc.

Functional Modeling

Functional modeling: Using the concept of abstract model, according to the relationship between data transmission and exchange within the software, decompose it layer by layer from top to bottom until all implementable software that meets the functional requirements is found.

Data Flow Diagram : It is a popular modeling technology in software engineering; it graphically depicts the data flow from the perspective of data transmission and processing, that is, the movement transformation process from input to output, and its basis is functional decomposition. . It starts from the environment diagram in a top-down manner and decomposes the functions all the way to the module description.

Data Modeling

Data Model: Use entity-relationship diagram (ER diagram) to establish a data model to depict data objects and their relationships; the diagram contains three elements: data objects (entities), attributes of data objects, and relationship between.

Data Object (Entity) is a representation of the review information required by the target system and only encapsulates the data; attributes define the characteristics of the data object; there are three types of relationships between data objects: one-to-one association and one-to-many association. , many-to-many relationship.

Behavior modeling method (Human Behavior Representation, HBR)

Behavior Model: Use a state-transition diagram (STD) to establish a behavior model to describe the system state and events that cause state changes; the diagram contains elements such as states, state transitions, and events.

Data Dictionary

Data dictionary: The data dictionary defines the characteristics of data objects and control information appearing in the data model, functional model and behavioral model in the form of entries, and gives their accurate definitions, including data flow processing, data files, data elements, and data origin and data sink, etc.

Class Diagram: Describes the class structure of the system and depicts the static structure of the system.

class relationship

Object Diagram : A static instantaneous snapshot that describes the objects in the system during operation; it is an instantiation sample of the class diagram at a certain point in time or within a certain time period during the operation of the system.

State Chart/Diagram: Describes the reactive dynamic behavior of an entity (object, system) under event stimulation and the resulting state changes; depicts the possible states of the entity, the events and response actions that can be responded to in each state, State migration.

Sequence Diagram: The sequence of message interactions between objects; emphasizing the time sequence of message delivery.

Communication Diagram : Describes the interactive collaboration relationship between objects; highlights the cooperation between objects.

Software Requirement Specification

After the requirements analysis is completed, a requirements document "System Requirements Specification" needs to be formed. It specifies requirements for a software system or subsystem and specifies the methods used to ensure that each requirement is met. It describes the functions and performance of the software system and those system constraints.

The requirements specification uses pictures and texts, combines the requirements model and the natural language description of the requirements to describe the software requirements, including functional and non-functional software requirements, a priority list of software requirements, etc.

Requirements Specification (SRS): Describes the requirements for a computer software configuration item and the methods used to ensure that the requirements are met.

Data Requirements Description (DRD): Describes the data that needs to be processed during the software development process and the requirements for data collection.

Chapter 4 Software Design and Implementation

Software design : starting from the software requirements specification, designing the overall structure of the software system based on the functions determined in the requirements analysis stage, dividing the functional modules, determining the implementation algorithm of each module, and writing specific codes to form a specific design plan for the software.

Four stages of software design :

Data design: the global data structure design of the software system, including data entities and attributes and their relationships.

Architecture design: represents the high-level design structure and decomposition structure of the software system, that is, component division, external attributes of components, and their mutual interactions.

Component interface design: The design of the interaction interface between components, including the functional and non-functional requirements of the component interface, interface interaction protocol, interface operation and implementation class definition, etc.

Component-level design: The specific design plan within the component. For example, object-oriented design classes and class relationship definitions, local data structures and algorithm designs within components, etc.

Software design management : During the software design and development process, software design engineers need to work with software quality assurance personnel, software configuration managers, etc. to effectively manage software design products to cope with various changes that occur during software development and operation and maintenance. .

Structured software design : It is developed based on technologies such as modularization, top-down, layer-by-layer refinement, and structured programming. It is a method that maps the data flow diagram obtained by structured analysis into the software architecture. Design methods. Its main task is to establish various design models based on demand analysis, and to determine whether these models meet the needs through analysis and evaluation of the design models.

Object-oriented software design

The main tasks of object-oriented software design are: based on object-oriented analysis, complete system structure design, interface design or human-computer interaction design, data design, class design and component design.

Data design in object-oriented design is not carried out independently; its class diagram is equivalent to the logical model of the data and can be easily converted into the physical model of the data.

The concept of "package"

When there are a large number of classes involved in the system, for the convenience of system implementation and maintenance, design classes are often aggregated into a large-grained "Package" according to the closeness of their relationship with each other. According to the definition of UML, a package is a named collection of modeling elements.

A package is a logical design concept; a package can contain other packages; a package has its own members; and a package can import other packages.

Design Patterns : Software design is highly empirical. Software design patterns are relatively mature and successful methods summarized from the software design process. They are a set of classification and cataloging summary of code design experience that are used repeatedly, known to most people, and are aimed at a specific type of problem. Common and reference design solutions that can be used for reference.

There are three main categories of usage patterns in software design methods :

Architecture Pattern: Defines the basic organizational structure form or scheme of a software system, reflects the responsibilities and relationships between subsystems or software components, and defines the architecture elements (subsystems, packages, classes, components) rules of relationships.

Design Pattern: Provides refined solutions for subsystems, components, or relationships between components of a software system. These patterns address elements unique to the design, such as component aggregation, connections between components, or mechanisms that affect component-to-component communication.

Framework: With the development of applications, certain integrated application patterns form a specific framework and become a specific skeleton infrastructure that has been implemented. The framework provides basic functions and specifies system elements, components and how they are connected. Developers only need to focus on the implementation of business logic.

Typical design patterns :

Factory Pattern is one of the most commonly used design patterns in Java. This type of design pattern is a creational pattern, which provides an optimal way to create objects. The creation logic is not exposed to the client when creating the object, and is pointed to the newly created object by using a common interface.

Abstract Factory Pattern: Create other factories around a super factory. The Gigafactory is also known as the factory of other factories. It provides an interface for creating a family (factory) of related objects without explicitly specifying their classes. Each generated factory can provide objects according to the factory pattern.

Builder Pattern: Use multiple simple objects to build a complex object step by step. It provides a way to create objects; a Builder class constructs the final object step by step. The Builder class is independent of other objects.

The Adapter Pattern converts the interface of a class into another interface that the client wants. This pattern combines the functionality of two independent interfaces; setting up a hybrid interface class is responsible for adding independent or incompatible interface functionality.

The Mediator Pattern is used to reduce the complexity of communication between multiple objects and classes. It provides a mediator class that usually handles communication between different classes and supports loose coupling, making the code easy to maintain.

MVC (Model-View-Controller, Model-View-Controller) pattern: used for layered development of applications.

Model: A model represents an object that accesses data. It can have logic that updates the controller when the data changes.

View: A view represents a visualization of the data contained by the model.

Controller: Controller acts on models and views. It controls the flow of data to model objects; it updates the view when the data changes. It separates the view from the model.

The core of SOA: identifying, designing and implementing services, service components (Components), and collaboration between services (Choreography).

SOMA: Construct SOA applications through service-oriented modeling, analysis and design activities.

Software implementation : Based on the software design model, write the program code of the target software system, conduct necessary tests on the code to discover and correct defects in the code, and deploy the runnable target code to the target computer for running.

Software implementation requires not only writing program code, but also ensuring the quality of the code , which involves many aspects of software development work, such as coding, testing, debugging, etc.

Software implementation : includes a series of development activities such as coding, testing, debugging, etc.

Coding: Based on software design models and documents, using programming language, write the program code of the target software system.

Unit testing: Perform unit testing on each basic module written to discover defects and problems in the module unit.

Software debugging: discover the cause of defects, locate the defect location, and then repair the code defects.

Software testing: Integration testing of multiple units up to the software system to discover and correct interface and parameter transfer problems between units.

Agile software development method (Agile Development Method) started in the 1990s and matured at the beginning of this century. The agile development method emphasizes being code-centered, writing only a few documents , responding to changes in software requirements quickly, lightly, proactively, and incrementally, and delivering runnable software systems continuously and in a timely manner.

Essence : Software development in a rapid incremental and iterative manner

Chapter 5 Software Quality and Software Engineering Management

Software quality refers to the satisfaction of user needs in terms of functionality and performance, compliance with prescribed standards and specifications, and certain recognized essences of formal software.

Software quality is the application of effective software processes to a certain extent to create useful products that provide significant value to producers and users.

Two aspects of the software process:

Software process quality : Good software processes can produce good products, and software process quality determines the quality of software products to a certain extent.

Software product quality : The extent to which the software conforms to clearly described functional and performance requirements, development standards clearly described in documentation, and implicit characteristics that any professionally developed software product should have, that is, the software meets the given requirements (functionality, performance , standards, characteristics, etc.).

Software quality involves three factors : the software's operating characteristics, its ability to withstand changes, and its ability to adapt to new environments.

Software quality management: Quality planning, quality control, quality measurement and verification, quality improvement and other quality-related coordinated activities of software organizations in the production of software products.

Software process refers to a series of related processes involved in the software life cycle; it is a collection of all technical activities and management activities in the entire process of people establishing, maintaining and evolving software products. A process is a collection of activities, and an activity is a collection of tasks.

Software process is a framework of tasks required to build high-quality software, that is, a series of steps to form a software product, including intermediate products, resources, roles, methods, tools, etc. used in the process.

Software process is mainly studied for software production and management, involving software development, engineering support and engineering management.

Basic software process : It can be divided into five processes according to the different subjects active in the process:

Acquisition process: are the activities and tasks performed by acquirers (demanders) with the purpose of obtaining products and services that meet the requirements expressed by customers. The process begins with defining customer requirements and ends with acceptance of the product or service requested by the customer.

Supply process: It is a series of activities and tasks that the supplier engages in to provide customers with software products or services that meet their needs. The purpose is to provide customers with a product or service that meets their needs.

Development process: It is a series of activities and tasks engaged in by software developers. Its purpose is to convert a set of requirements into a software product or system; including 13 activities: process implementation preparation, system requirements analysis, system structure design, system Requirements analysis, software body structure design, software detailed design, software coding and testing, software integration, software qualification testing system, integrated system qualification testing, software installation, software acceptance support, etc.

Operation process: It is a series of activities and tasks performed by system operators. The purpose is to run the software product in the environment expected by the software product and to provide support for the maintenance of the software product.

Maintenance process: It is a series of activities and tasks performed by the maintainer. The purpose is to modify the delivered system or software product in order to correct its errors, improve its performance and other attributes, or to modify it due to environmental changes. Adjustment.

Software process maturity is an important concept in software process improvement; it refers to the degree to which a specific software process is clearly defined, managed, measured, controlled, and effective.

Software process infrastructure refers to the basic framework and structural framework of the software process, including the positions and responsibilities of organization and management, the technical tools necessary to support the definition of the process, the development of the process, the activity acquisition and analysis of process-related performance feedback, and the continuous process improvement activities. and platform.

Software Process Improvement SPI (Software Process Improvement): It is a series of activities in the software process in order to more effectively achieve the purpose of optimizing the software process and at the same time improve or change the software process.

Software testing is an activity with the purpose of evaluating the quality or capabilities of a program or software system (Bill Hetzel).

Software testing is the process of executing a program or system with the purpose of finding errors (GJ Myers).

Software testing process: design data (test cases) -> run test cases (program to process data) -> judge the running results (whether they meet the expected results)

Key tasks of software testing: clarify the software test object (program code), design software test cases, run the program code (input, output and analyze test cases), form result evaluation and judgment (compare with expected results to determine whether there are defects)

Software testing activities : including unit testing (Unit Testing), integration testing (Integration Testing), validation testing (Validation Testing), system testing (System Testing), etc.

Testing Case: A test case is a set of test inputs, execution conditions and expected results designed for a specific purpose. A test case is the smallest test entity for execution; it is to design a scenario so that the software program can run normally and achieve the execution results designed by the program in this scenario.

Unit Testing: Verify whether the code written by the developer can be executed in the way envisioned and produce results that meet the expected values, ensuring that a reliable program unit that meets the requirements is produced. Unit meaning: Structured program units are modules; object-oriented program units are classes. Unit testing scope: Test the basic components of the software (component or module), focusing on the internal processing logic and data structure in the component (based on detailed design). Unit test content: unit interface, local data structure, code execution path, code boundary conditions, error and exception handling

Integration Testing: Also known as assembly testing or joint testing. On the basis of unit testing, the program units that constitute the target software are gradually assembled into subsystems or systems according to the overall design requirements, and their interfaces and integration are tested for defects. Integration testing is a systematic technique for constructing software architecture, aiming to find interface-related errors. Structured integration testing tests calling relationships; object-oriented integration testing tests object dependencies.

System Testing: System testing is performed by combining the integrated software system as a whole with other elements such as computer hardware, peripherals, supporting software, data, and personnel, and conducting it in the actual operating and usage environment. A series of tests. System testing is based on integration testing to check whether the software system meets the requirements of all aspects of the requirements specification.

Regression Testing: Regression testing is to verify that changes or modifications to the system do not affect the original functions, and to ensure that the changes to the current functions are correct. Regression testing can occur at any stage of software testing, including unit testing, integration testing and system testing. The annoying reason is that it requires frequent repetitive work.

Agile testing model of the software testing process - This model is a testing activity for agile software development iterations; testing activities are carried out continuously with the agile iterative development process, and are mainly conducted on new functions or features within a limited time Test and continuously revise quality metrics to ensure frequent delivery of working software products to customers.

White box testing : also known as "structural testing" and "logic-driven testing"; it regards the test object as a transparent box, designs or selects test cases based on the internal logical structure and relevant information of the program, and analyzes all logical paths of the program. Carry out tests to see if the program runs normally and meets the design requirements.

The premise of white-box testing is that the logical structure of the software module is known. Based on this, the basic path of the module can be grasped and the program module can be checked whether it runs according to the internal workflow; if not, there is a defect.

White box testing is mainly used for unit testing and integration testing.

Black box testing : also known as "functional testing" and "data-driven testing"; it treats the test object as a black box. The tester does not consider the internal logical structure and internal characteristics of the program at all, and only checks the program based on the program's requirements specifications. Whether the function meets its functional description.

Black box testing designs test cases based on known program functions and performance (rather than internal details) and verifies whether each function and performance of the program is normal through testing.

Black box testing is mainly used for integration testing, confirmation testing and system testing.

Software maintenance refers to the process of modifying the software in order to correct errors or meet new needs after the software system is delivered for use. IEEE definition: Software maintenance refers to the process of modifying software systems and other components after the software is delivered to users to fix defects, improve performance or other attributes, enhance software functions, and adapt to changing environments.

There are four main types of software maintenance : corrective maintenance (or corrective maintenance), adaptive maintenance, perfective maintenance or enhancement, and preventive maintenance or reengineering.

Corrective maintenance refers to correcting errors and defects that have occurred during the system development phase but have not yet been discovered during the system testing phase. Once users discover defects while using the software, they will request corrective maintenance from the developers.

Adaptive maintenance refers to the transformation of software to adapt to changes in information technology and management needs, new operating environments and platforms. This kind of maintenance work should also be carried out in a planned and step-by-step manner just like system development.

Perfection maintenance is a modification made to expand functions and improve performance. It mainly refers to adding some functions and performance features to existing software systems that were not specified in the system analysis and design stages; including improvements to processing efficiency and programming.

Preventive maintenance is a maintenance activity that improves the reliability and maintainability of software systems and lays the foundation for future software improvements. In order to adapt to future changes in the software and hardware environment, preventive new functions should be actively added so that the application system can adapt to various changes without being eliminated.

Software maintenance technologies include software reverse engineering, code reorganization, design reconstruction, and software reengineering.

Code Refactoring: Reorganize the program code and improve its internal structure without changing the software function, so that the reorganized code has better maintainability and can effectively support code changes.

Reverse engineering refers to the process of identifying system components and their interaction relationships by understanding and analyzing the target system, and then using other forms or higher-level abstractions to create system representations (high-abstraction level software artifacts).

Software design and reconstruction (Redesign/Restructure): Improve the quality and performance of the software by adjusting the program code, making the design pattern and architecture of the program more reasonable, and improving the scalability and maintainability of the software.

Software Reengineering: The process of achieving higher quality software systems by analyzing and changing the software architecture. Reengineering includes both reverse engineering and forward engineering.

Software evolution refers to the process in which programs continuously adjust and enhance functions and structures to adapt to changing software requirements, meet new software requirements, or improve the quality of software systems.

Software quality assurance is the establishment of a planned and systematic approach to assure management that the proposed standards, procedures, practices and methods are correctly adopted in all projects. Its purpose is to verify that software conforms to standards through reviews and audits of software products and activities

Software quality assurance process: mainly includes planning, supervision, recording, analysis and reporting.

Software Project Management : The process of measuring, analyzing, planning, organizing and controlling the processes, personnel, products, costs, schedule and other elements involved in software projects to ensure that the software project follows the predetermined cost, schedule, and schedule. Quality requirements are successfully completed and software products or services that meet user requirements are submitted.

The main aspects involved in software project management are: 4 Ps, namely People, Product, Process and Project.

Software Metrics : The continuous quantitative description and process of data definition, collection and analysis of software development projects, processes, products and resources, such as the scale, cost, workload, quality, etc. of software projects, including customers Satisfaction measurement, quality measurement, project measurement, brand equity measurement, intellectual property value measurement, etc.

Software Project Estimation : Prediction of the workload, time, cost, etc. spent on the entire software development process including requirements analysis, design, coding, testing, integration delivery, etc.

Software project plan : a pre-planning of the activities, personnel arrangements, task division, development progress, resource allocation and use involved in the implementation of the software project.

Software Requirement Management (Software Requirement Management) tasks: Obtain, document and review user requirements, and control and manage changes in user requirements. Content: requirements change control, requirements tracking, requirements status tracking, requirements document version control.

Software Risk Management is the process of analyzing, predicting, evaluating, and monitoring various risks in the software development process. Software risks: Possible events that may affect or cause losses to the implementation of software projects, or even lead to failure. Types of software risks: software scale risk, business impact risk, customer-related risk, software process risk, development environment risk, development technology risk, developer risk, etc.

Software Configuration : It consists of all information items (including documents, codes, data, standards and specifications, etc.) generated during the software engineering process. It can be regarded as the specific form of the software (software configuration items) at a certain moment. Instant image. Software Configuration Management (SCM, Software Configuration Management): identifies, stores, changes and distributes software products, records and reports their status, implements version control and change control procedures, and conducts audits to verify the correctness of software products. Ensure the integrity and traceability of software configuration items.

Software Configuration Item (SCI, Software Configuration Item): Work products generated during the software life cycle that require configuration management, including various documents, program codes, data, standards and specifications, etc.

Software Quality Management Software quality management refers to the quality activities implemented by software development organizations to ensure software project requirements.

Chapter 6 Software Engineering Education and Career Development

Main course series for software engineering major

Basic theory categories: basic mathematics theory, basic theory of computer science

Computer majors: Computer software and hardware system professional courses, technical basic courses

Software Engineering: Core Courses on Software Engineering Methods and Technology

Software development platforms and tools: mainstream software platforms, programming languages, software development tools

Software Engineering Practice Category: Software Engineering Project Design and Professional Comprehensive Design

Professional specialization or industry application: professional elective courses, interdisciplinary elective courses, and applied industry elective courses

Enterprise and Economic Management: Enterprise Management and Entrepreneurship Course, Economic and Law Course

Professional experiment

This part recommends that students majoring in software engineering review after completing the experiment. The exam requires understanding the experimental content, but it is not particularly difficult and is often combined with the knowledge from the previous requirements analysis course.

take an exam

The software engineering professional examination consists of concept explanation questions, judgment questions, short answer questions and experimental analysis questions. The elaboration questions require an understanding of basic concepts (some parts require special memorization). This year, the definitions of software requirements engineering, software architecture, software engineering, software design style, and the development of software engineering were tested. The true-false questions are quite obvious. The following short-answer questions first explain what MVC is, and then draw a model diagram. The second one explains object-oriented and process, and requires an object-oriented process diagram. This part also includes the experimental analysis part later. xxf said that if you write hard, you will be given points (laughs). One of the experimental analysis questions asks you to draw a use case diagram, and the other is to draw a class diagram.