Software Engineering

Unit - 4

Coding

The coding is the process of transforming the design of a system into a computer language format.
This coding phase of software development is concerned with software translating design
specification into the source code. It is necessary to write source code & internal documentation
so that conformance of the code to its specification can be easily verified.

Coding is done by the coder or programmers who are independent people than the designer. The
goal is not to reduce the effort and cost of the coding phase, but to cut to the cost of a later stage.
The cost of testing and maintenance can be significantly reduced with efficient coding.

Characteristics of good coding/good coding style

Readability: A good high-level language will allow programs to be written in some methods
that resemble a quite-English description of the underlying functions. The coding may be done in
an essentially self-documenting way.

Portability: High-level languages, being virtually machine-independent, should be easy to

develop portable software.

Generality: Most high-level languages allow the writing of a vast collection of programs, thus
relieving the programmer of the need to develop into an expert in many diverse languages.

Brevity: Language should have the ability to implement the algorithm with less amount of code.
Programs mean in high-level languages are often significantly shorter than their low-level
equivalents.

Error checking: A programmer is likely to make many errors in the development of a computer
program. Many high-level languages invoke a lot of bugs checking both at compile-time and
run-time.

Cost: The ultimate cost of a programming language is a task of many of its characteristics.

Quick translation: It should permit quick translation.

Efficiency: It should authorize the creation of an efficient object code.

Modularity: It is desirable that programs can be developed in the language as several separately
compiled modules, with the appropriate structure for ensuring self-consistency among these
modules.
Widely available: Language should be widely available, and it should be feasible to provide
translators for all the major machines and all the primary operating systems.

A coding standard lists several rules to be followed during coding, such as the way variables are
to be named, the way the code is to be laid out, error return conventions, etc.

Code Efficiency

Code efficiency is a broad term used to depict the reliability, speed and programming methodology
used in developing codes for an application. Code efficiency is directly linked with algorithmic
efficiency and the speed of runtime execution for software.

Recommendations for code efficiency include:

 To remove unnecessary code or code that goes to redundant processing
 To make use of optimal memory and nonvolatile storage
 To ensure the best speed or run time for completing the algorithm
 To make use of reusable components wherever possible
 To make use of error and exception handling at all layers of software, such as the user
interface, logic and data flow
 To create programming code that ensures data integrity and consistency
 To develop programming code that’s compliant with the design logic and flow
 To make use of coding practices applicable to the related software
 To optimize the use of data access and data management practices
 To use the best keywords, data types and variables, and other available programming
concepts to implement the related algorithm

Code Documentation:

Code documentation is a manual-cum-guide that helps in understanding and correctly utilizing

the software code. The coding standards and naming conventions written in a commonly spoken
language in code documentation provide enhanced clarity for the designer. Moreover, they act as
a guide for the software maintenance team (this team focuses on maintaining software by
improving and enhancing the software after it has been delivered to the end user) while the
software maintenance process is carried out. In this way, code documentation facilitates code
reusability.

Generally, internal documentation comprises the following information.

 Name, type, and purpose of each variable and data structure used in the code
 Brief description of algorithms, logic, and error-handling techniques
 Information about the required input and expected output of the program
 Assistance on how to test the software
 Information on the upgradations and enhancements in the program.
Information Hiding:

Information hiding is a software design principle, where certain aspects of a program or module
(the “secrets”) are inaccessible to clients. The primary goal is to prevent extensive modification to
clients whenever the implementation details of a module or program are changed.

Information hiding can be thought of as a three-step process:

1. Identify all of the pieces of a design that are likely to change or other design details that
you might want to hide
 We call these our “secrets”, and we want to hide these details from external entities.
2. Isolate each secret into its own module, class, or function
 This is done so that changes to the secret are isolated and don’t affect the rest of the
program
 Parnas: “All data structures that reveal the presence or number of certain
components should be included in separate information hiding modules
with abstract interfaces.”
3. Design intermediate interfaces that are insensitive to changes in the underlying secrets.
 That is, make sure that your secrets aren’t leaked or revealed by your interfaces’

Implementation issue and programming support environment

Implementation issues refer to the challenges and obstacles encountered during the deployment of
a software system. Some of the common implementation issues are:

1. Inadequate Planning: The lack of proper planning and preparation can result in
implementation delays and budget overruns.
2. Compatibility Issues: The software system may not be compatible with the existing
hardware, software, or infrastructure, leading to implementation problems.
3. Integration Issues: The software system may not be able to integrate with other systems,
causing compatibility problems.
4. Technical Challenges: Technical challenges such as data migration, data loss, and system
downtime can arise during implementation.
5. User Acceptance: The end-users may not be accepting of the new software system, leading
to resistance and decreased productivity.
6. Cost Overruns: The cost of the implementation may exceed the budget, resulting in
financial strain on the organization.

A programming support environment refers to the tools, resources, and services available to
support the development and deployment of software systems. Some of the key components of a
programming support environment include:

1. Development Tools: This includes integrated development environments (IDEs), code

editors, compilers, and debuggers.
2. Testing Tools: This includes software testing tools such as automated testing frameworks,
code coverage tools, and load testing tools.
 3. Source Control: Source control is a version control system that allows developers to
manage and track changes to their code.
4. Collaboration Tools: Collaboration tools allow developers to work together on a software
project, such as issue tracking systems, chat tools, and version control systems.
5. Performance Optimization Tools: This includes tools that help optimize the performance
of the software system, such as profiling tools, memory analyzers, and performance tuning
tools.
6. Technical Support: Technical support is essential to ensure that the software system is
deployed smoothly and that any problems are quickly addressed.

Relationship between design and implementation

The relationship between design and implementation is crucial in software development. Design
is the blueprint of the software system, while implementation is the process of turning that design
into a functioning software system.

Design provides the foundation for the software system, including its architecture, components,
and user interfaces. It lays out the plan for how the software system will work and what it will look
like. Implementation takes the design and creates a functional software system by writing code,
testing it, and deploying it to a target environment.

Design and implementation are interdependent and must be closely linked to ensure that the
software system meets the business requirements and delivers the desired outcomes. A well-
designed software system that is not properly implemented will not be effective, and an poorly
designed software system will be difficult to implement and will not deliver the desired outcomes.