Summary of the key points of constructing law enforcement

Introduction to the first chapter

The definition of software engineering in construction law enforcement is: the process of applying systematic, orderly and quantifiable methods to the development, operation and maintenance of software. Includes: Software requirements analysis, software design, software construction, software testing and software maintenance. Software engineering is related to subjects such as computer science, computer Engineering, management, mathematics, project management, quality management, software ergonomics, systems engineering, industrial design and user interface design.

Software is defined as an ordered set of instructions and data that can be run on computers and electronic devices.

Because software development has the characteristics of complexity, invisibility, variability, obedience and non-continuity, the development of software has not been developed as fast as hardware.

Computer science can be divided into the field of partial scholarship and the field of partial theory, the former is closely related to mathematics and logic, while the latter focuses on people.

The goal of software engineering: to create "good enough" software, among which factors to consider include: User satisfaction, reliability, quality and maintainability of software processes.

Chapter II Personal Technology and communication

Unit test: Guarantee of stable and quantitative quality of the module. Guaranteed 100% Overwrite code. Ensure the correctness of the program, the test does not produce post-function, fast, reproducible, automatic test.

Effectiveness Analysis: Sample-by-code injection. Analysis to find the problem after optimization.

Personal development process: focus on requirements analysis and testing, rather than spending a lot of time writing code.

Chapter III Growth of software engineers

Software development process: including development, operation, maintenance.

Ic:individual contributor, personal developer. Understand issues, needs and tasks, propose multiple solutions and estimate workloads, communicate and decide on feasible options, execute, write code, collaborate to test implementations, fix bugs, and be responsible for results.

The process of the engineer's growth: accumulating knowledge, upgrading skills, accumulating knowledge and experience in related fields, understanding common software design ideas and software engineering ideas, upgrading professional skills, practical results.

The opposite of skills: solving problems. Problem solving is the ability to improvise.

The fourth chapter two people cooperation

Code specification: Code style specification, code design specification

Code Style Specifications: Indents, line width, parentheses, line breaks with {} lines, branches, names, underscores, capitalization, comments

Code Design Specifications: Functions, Goto, error handling (parameter handling, assertions). There are other requirements for classes in C + +

Code review: See if the code solves the problem correctly within the framework of the Code specification. Self-review + Peer review + team review. Discover code errors, logic errors, algorithmic errors, potential errors and regression errors, where to improve, and imparting experience.

Pair programming: Complementary, interchangeable, review and exchange at any time. Regular exchange, not continuous work, equal decision-making power. Phase-in phase--run-in stage (phase of disintegration).

Evaluation of the human hierarchy: behavior and consequences, habits and motivations--nature and intrinsic properties.

The way to persuade people: sandwiches = bread + meat + bread.

Fifth Chapter team and process

The characteristics of the team: there are consistent collective goals, each have a division of labor, mutual reliance on cooperation.

Software team mode: Nest Bee mode, attending physician mode, star mode, community mode, amateur theater mode, Secret Team, spy team, symphony Orchestra mode, jazz mode, functional team mode, bureaucratic model.

Development process: CODE & FIX; waterfall mode and various variants = Analog version + final version; Unified Process (RUP) = Business Modeling + requirements + Analysis design + implementation + Debug + Deployment + Configuration Change management + project management + environment; boss-driven process; Progressive delivery process, MVP (minimum viable product) & MBP (the strongest and most beautiful products).

The sixth chapter Agile process

Agile development Principles: Early and continuous delivery, demand change to improve competitive advantage, regular release, daily work together, project core enterprising and full trust, maintain effective communication, measure project progress with available software, sustainable development, focus on technology and design, keep concise, self-management, summarize how to improve efficiency and put into action.

Agile Process = Product Backlog + sprint + Sprint. Decide what problems to solve, decide what each person should do, report the completion degree and plan every day. Time-driven.

Agile Team: Self-management, self-organization, multi-functional.

Chapter Seventh MSF

The Msf:microsoft solution Framework supports scrum and agile.

MSF Basic principles: Promote information sharing and communication, work for a common vision, fully empower and trust each other, share responsibility for projects, deliver incremental value, maintain agility, anticipate and adapt to change, invest in quality, learn all experiences, and cooperate with customers.

MSF teams: Product management, project management, development, release management, testing, user experience.

MSF Process Model: deployment, development------plan---

MSF Agile Development Model: Focus on user communication, prevent defects, pay attention to the quality of actual combat conditions, streamline the process, and straight to the subject.

Eighth Chapter Requirements Analysis

Software requirements: Get and guide requirements----analyze and define requirements----manage requirements in the software lifecycle.

Software Requirements Division: Functional requirements, development process requirements, non-functional requirements, comprehensive requirements.

Software stakeholders: Users (direct user), customers (recipients of software), market analysts, regulatory agencies, software engineers.

Get User requirements (user survey): Focus group (Find target user representative), in-depth interview, card classification (classification of requirements as cards), user survey questionnaire, user log research, anthropological survey (in-depth understanding of user habits), eye tracking research, rapid prototyping Research (paper model), A/B testing.

Competitive Demand Analysis framework: NABCD model. Need + approach + Benefit + competitors + Delivery.

Functional positioning and prioritization: Killer function (CORE) • Peripheral function (UI), required requirements, and ancillary requirements.

Nineth Chapter Project Manager

Pm:program Manager

PM Solve the problem: Exchange cost problem, demand transformation, functional design, domain.

PM Risk Management: Code check-in, technical risk, natural risk, legal risk.

Level of risk management: crisis management, mitigating and preventing problems, anticipating, turning problems into opportunities.

PM Competency requirements and tasks: observing, understanding and fast learning ability, analytical management ability, certain professional ability, self-reflection ability.

PM Task: Lead the team to form a goal, a vision; manage the software lifecycle; Create and maintain specifications; Analyze lead members to agree on defects, change and implement; lead members to maintain balance, track project progress, ensure the release of satisfactory software, collect data, analyze pros and cons, and boost morale.

Tenth. Typical users and scenarios

Typical users: different characteristics, different needs, different attributes (age, income, environment, ability, preferences, etc.), in-depth understanding of user needs.

Scenario: Background (user information), scene (what happens when the user uses it). Design scenarios based on requirements.

Use case: Title, role, main success scene, extended scene;

Specification: Software function description (concepts, assumptions, boundary conditions, interactions, side effects, quality of service) + software technotes (principle P218).

Function-driven design: FDD. Constructs the overall model, constructs the function list, develops the development plan, the function design stage and so on the concrete realization function.

The 11th chapter Software design and realization

Analysis and Design methodology: Requirements analysis (entity, abstract attributes, understanding requirements)--design and implementation phases (how to address requirements), testing and release phase (whether to address requirements)

Graphical Modeling and Analysis methods: express the relationship between entities and entities (mind Map, Entity Relationship diagram, use case diagram UCD), EXPRESS DATA Flow (hierarchy), express control flow, unified expression (UML diagram).

Other design methods: Formal methods, literary programming.

From spec (design document) to implementation: control code Check-in, follow standard development workflow, complete code.

Ongoing management of the development phase: Behind closed doors (no interruption), daily build, build master (the person who has the wrong, responsible for the next build), strict all errors (rules and Process Control), bug Hell (Control the total number of bugs each person can make, more than the priority to fix the bug).

12th Chapter User Experience

User Experience Essentials: User First Impressions (target users, keep only the most important features?) ), from the perspective of the user (requirements, circumstances, user capabilities), remember the user choice (to maintain the same conditions in the same system, optimize selection), short-term stimulation and long-term impact (long-term use needs to drink much change and better adaptability), do not allow users to make simple mistakes (increase the difficulty of simple error), user experience , emotional design (instinct, behavior, reflection).

User experience design steps and goals: cognitive resistance, interaction mode, behavior.

Evaluation criteria: To provide feedback as soon as possible, the system interface in line with the user's practical practice, the user has control, consistency and standardization, suitable for all types of users, to help users identify, diagnose and repair errors, necessary tips and help documentation.

The 13th Chapter Software test

Basic noun: BUG, test case, Test SUITE. Symptoms, procedural errors, root causes.

Classification: Design Method (black box, white case), test purpose (Functional test = unit Test + functional Test + integration Test + Scene Test + system Test + external use test, non-functional test = stress Test + performance Test + Accessibility Test + local globalization Test + compatibility Test + configuration Test + usability Test + Safety testing), test timing & Function (smoke test, build verification test, acceptance test).

Test methods: Unit test, Code Coverage test, build verification test, acceptance test, exploratory testing (Ad hoc test), regression test, scenario/integration/system test, partner test (code pre-check build test), performance test, stress test, internal/external public test, usability test, Bug Bash.

Actual test: Test Design Manual + test Case + Error report + Close defect report + test report.

Testing Tools: Manual testing + automated testing.

The 14th Chapter Quality Assurance

Quality of software = Program Quality + Software engineering quality (visibility of development process, risk control, intermediate stage delivery quality, management tool factors, cost control, quality indicators completion). Measurement criteria: CMMI

Software Quality Assurance (QA): All activities, including testing, that the software team makes in order for the software to meet pre-defined quality standards.

Chapter 15th stability and release phase

Version: Aapha (inside), Beta (public test), ZBB (0 bug build) RC (Release Candidate), RTM (final release), RTW (Web release version).

Consultation: For each bug, the repair/design would have been so/not fixed/deferred fix.

Progressive release: For different user groups, use different frequencies for publishing.

Summary meeting: After publishing, explore the root cause of the problem.

16th. Innovation in IT Industry

Innovation: Inspiration vs daily accumulation and thinking, improved innovation vs disruptive innovation, good ideas vs preconceived advantages, first proposed vs do best, domain knowledge vs implementation ideas, strongest technology vs. meeting user needs, team success vs. innovation capability.

Innovation opportunity: One step ahead, driving the trend development, technical maturity curve guidance.

Innovative approach: SWOT analysis Framework (strengths + weaknesses + opportunities + threats), balance momentum & acceleration control product life cycle ...

17th. People, Performance and professional ethics

Participants: devote themselves (big decisions), participate, and watch.

Rasic: Take responsibility, be responsible, provide support, consult, and inform the participants.

Performance management: Assessment (technical capability, labor productivity, contribution to the team, contribution to the product), differentiated treatment (2:7:1).

Contradiction: High efficiency, multiple bugs VS inefficient bugs.

Team cooperation stage: embryonic stage (relying on leadership)--run-in phase (doubt & conflict)--phase (consensus)--creative stage (high degree of autonomy, responsibility conversion).

The professional Ethics of software engineers: In line with the public interest, maximizing the interests of clients and employers, satisfying the highest professional standards, complete independent professional judgments, leading the use of complex ethics management, software engineers to ensure professional integrity and interests, support and help colleagues, and continuously improve professional standards.

Readers are welcome to supplement or exchange ideas in comments.

Summary of the key points of constructing law enforcement