What are Construction Practices in Software Engineering Practice? - Part 2 : Testing Principles

In software engineering practice, construction practice includes coding and testing tasks and principles. Testing is a process of finding out an error. A good testing technique is one which gives the maximum probability of finding out an error. The main objective of testers is to design tests that uncover different classes of errors with minimum amount of effort and time.

Some testing principles include:
- From a customer point of view, severe defects are one that cause failure of the program so all the tests that are defined should meet the requirements of the customer.
- Planning of tests should be done long before testing begins. When the design model is made, test cases cab be defined at that very point. Tests can be planned before any code has been generated.
- Generally, individual components are tested first and then the focus is shifted to integrated components and finally the entire system.
- It is not possible to execute different combination of paths during testing. This means that exhaustive testing is not possible.

In a broader software design context, we begin "in the large" by focusing on software architecture and end "in the small" focusing on components. In testing, the focus is reversed.

What are Construction Practices in Software Engineering Practice? - Part 1

In software engineering practice, construction practice includes coding and testing tasks and principles. Coding involves direct creation of source code, automatic generation of source code and automatic generation of executable code using fourth generation programming languages.

CODING PRINCIPLES

Coding principles include preparation principles, coding principles, validation principles.
Preparation principles include:
- good understanding of the problem is necessary.
- good understanding of design principles and concepts.
- choose the right programming language and environment.
- unit tests that are applied once the component you code is completed.

Coding principles include:
- choose data structures.
- constrain algorithms.
- choose software architecture and interfaces.
- nested loops should be simple and easily testable.
- conditional logic should be simple.
- variable names should be meaningful.
- code should be self documenting.

Validation principles include:
- a code walk-through is conducted.
- unit tests are performed.
- code re-factoring is done.

What is software engineering practice? What are seven principles focussing on software engineering practice?

Practice is an array of concepts, principles, methods and tools that should be considered while software is planned and developed. The software process provides everyone involved in the creation of computer based system with a road map to reach the destination. Practice provides you with the detail that is needed to drive along the road. It helps you to understand the concepts and principles that must be understood and followed to drive safely and rapidly. Practice encompasses the technical activities that produce all work products that are defined by the software process model that has been chosen. Three elements of practice that are chosen are: concepts, principles and methods.

According to David Hooker, there are seven core principles that focus on software engineering practice:
- All the decisions should be made keeping in mind that one reason for the existence of a software system is to provide value to the all of its users.
- To have a more easily understood and maintained system, the design should be as simple as possible as one should keep in mind that software design is not a sloppy process. Keep in mind that simple does not mean 'quick and dirty'.
- For a software project to begin and end successfully, a clear vision is very necessary without which the software system weakens.
- The software system should be specified, designed and implemented in a manner that someone else will have to understand what you are doing.
- Software systems must be ready to adapt the changes in specifications and hardware platforms. One should not design the software system into a corner.
- The hardest goal while developing a software system is the ability to reuse it. Reuse can save time and effort. Forethought and planning is very important to realize reuse at entry level of the system development process.
- A clear, complete thought before action almost always produces better results.

CMMI - Generic goals and practices in Process Areas

Each process area is defined by a set of goals and practices. There are two categories of goals and practices:
- Generic goals and practices (GG & GP): They are part of every process area.
- Specific goals and practices (SG & SP): They are specific to a given process area.

A process area is satisfied when company processes cover all of the generic and specific goals and practices for that process area.
Capability Maturity Model Integration (CMMI)--CMMI for Development, Version 1.2—contains 22 Process Areas that describe the aspects of product development that are to be covered by organizational processes.

Generic goals and practices

GG 1 Achieve Specific Goals
- GP 1.1 Perform Specific Practices.
GG 2 Institutionalize a Managed Process
- GP 2.1 Establish an Organizational Policy.
- GP 2.2 Plan the Process.
- GP 2.3 Provide Resources.
- GP 2.4 Assign Responsibility.
- GP 2.5 Train People.
- GP 2.6 Manage Configurations.
- GP 2.7 Identify and Involve Relevant Stakeholders.
- GP 2.8 Monitor and Control the Process.
- GP 2.9 Objectively Evaluate Adherence.
- GP 2.10 Review Status with Higher Level Management.
GG 3 Institutionalize a Defined Process
- GP 3.1 Establish a Defined Process.
- GP 3.2 Collect Improvement Information.
GG 4 Institutionalize a Quantitatively Managed Process
- GP 4.1 Establish Quantitative Objectives for the Process.
- GP 4.2 Stabilise Subprocess Performance.
GG 5 Institutionalize an Optimizing Process
- GP 5.1 Ensure Continuous Process Improvement.
- GP 5.2 Correct Root Causes of Problems.

Benefits of Capability Maturity Model (CMM)

Quality is the very essence of any organization. An individual is known by the level of quality he/she possesses. Similarly in an organization, be it a products or services company, the organisation is identified in the market by the level of quality it maintains.
The CMM provides software organizations with guidance on how to gain control of their processes for developing and maintaining software and to gradually evolve towards a culture of software engineering and management excellence.

Fundamentally speaking CMM helps an organization in two ways :
- Firstly, CMM instills definite practices, which results in an increase in profitability.
- Secondly and most importantly is the immediate change it brings about in an organization's culture and mentality, thereby helping it to climb up the CMM ladder.

The advantages of moving up the CMM ladder are evident in a large number of organizations :
- A shift from reactive to proactive management.
- Helps build a skilled and motivated workforce.
- Cuts cost in development and support system.
- Shortens delivery schedules and improves delivery of requirements.
- Results in customer satisfaction.
- Improves quality of software products.
- Induces robustness.
- Improves management decision-making.
- Introduces newer technology thus creating competitive advantages.

At Level 1 - Initial level : No benefits, inconsistency, schedule and budget overruns and defective applications.
At Level 2 - Repeatable level : By achieving CMM Level 2, projects can set realistic expectations, commit to attainable deadlines and avoid the Level 1 "death marches" on nights and weekends that produce excessive defects.
At Level 3 - Defined level : At Level 3, IS organizations use historical measures describing the performance of a common application development process as the basis for their estimations.
At Level 4 - Managed level : Predictable results. Knowledge of factors causing variance and reuse.
At Level 5 - Optimizing level : Continuously targeting improvements results

Many of the initial benefits from CMM-based improvement programs result from eliminating rework.

Introduction to Software Engineering Practice Cont...

Construction incorporates a coding and testing cycle in which source code for a component is generated and tested to uncover errors. Integration combines individual components and involves a series of tests that focus on overall function and local interfacing issues.
Coding principles define generic actions that should occur before code is written, while it is being created, and after it has been completed. Although there are many testing principles, only one is dominant : testing is a process of executing a program with the intent of finding an error.
During evolutionary software development, deployment happens for each software increment that is presented to the customer. Key principles for delivery consider managing customer expectations and providing the customer with appropriate support information for the software. Support demands advance preparations. Feedback allows the customer to suggest changes that have business value and provide the developer with input for the next iterative software engineering cycle.

Introduction to Software Engineering Practice

Software engineering practice encompasses concepts, principles, methods, and tools that software engineers apply throughout the software process. Every software engineering project is different, yet a set of generic principles and tasks apply to each process framework activity regardless of the project or the product.
A set of technical and management essentials are necessary if good software engineering practice is to be conducted. Technical essentials include the need to understand requirements and prototype areas of uncertainty, and the need to explicitly define software architecture and plan component integration. Management essentials include the need to define priorities and define a realistic schedule that reflects them, the need to actively manage risk, and the need to define appropriate project control measures for quality and change.
Customer communication principles focus on the need to reduce noise and improve bandwidth as the conversation between developer and customer progresses. Both parties must collaborate for the best communication to occur.
Planning principles all focus on guidelines for constructing the best map for the journey to a completed system or product. The plan may be designed solely for a single software increment, or it may be defined for the entire project. Regardless, it must address what will be done, who will do it, and when the work will be completed.
Modeling encompasses both analysis and design, describing representations of the software that progressively become more detailed. The intent of the models is to solidify understanding of the work to be done and to provide technical guidance to those who will implement the software.