What is Construction Practice in Software Engineering ?

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. The construction activity encompasses a set of coding and testing task that lead operational software that is ready for delivery to the customer or end-user.

Coding Principle and Concepts

The principles and concepts that guide the coding task are closely aligned programming style, programming languages, and programming methods. However, there are a number of fundamental principles that can be stated:

Preparation principles :
  • Understand the problem you’re trying to solve.
  • Understand basic design principles and concepts.
  • Pick a programming language that meets the needs of the software to the hilt and the environment in which it will operate.
  • Select a programming environment that provides tools that will make your work easier.
  • Create a set of unit tests that will be applied once the component you code is completed.

Coding principles :
  • Constraint your algorithm by following structured programming practice.
  • Select data structure that will meet the needs of the design.
  • Understand the software architecture and create interfaces that are consistent.
  • Keep conditional statement as simple as possible.
  • Create nested loops in a way that makes them easily testable.
  • Select meaningful variable names and follow other local coding standards.
  • Write code that is self-documenting.
  • Create a visual layout that aids understanding.

Validation principles :

1. Build architectural infrastructure,
  • Review the architectural design.
  • Code and test the components that enable architectural infrastructure.
  • Acquire reusable architectural patterns.
  • Test the infrastructure to ensure interface integrity.

2. Build a software component.
  • Review the component- level design.
  • Create a set of unit tests for the component.
  • Code components data structures and interface.
  • Code internal algorithms and related processing functions.
  • Review code as it is written.
  • Look for correctness.
  • Ensure that coding standards have been maintained.
  • Ensure that the cod is self- documenting.

3. Unit test the components.
  • Conduct all unit tests.
  • Correct errors uncovered.
  • Reapply unit tests.

4. Integrate completed components into the architectural infrastructure.



Next Topic :

No comments:

Post a Comment