Coding
The coding is the process of transforming the design of a system into a
computerlanguage format. This coding phase ofsoftware development is
concerned withsoftware translating design specificationinto the source code. It is
necessary towrite source code & internal documentationso that conformance of the
code to its specification can be easily verified.
Goals of Coding
1. To translate the design of system into a computer language format:
2. To reduce the cost of later phases:
3. Making the program more readable:
Structured Coding Techniques
Structured coding techniques aids inlinearizing the control flow through
acomputer program so that the executionsequence follows the sequence in
which thecode is written.
The following are some of the golden rules to beconsidered for
structured coding.
1.Single entry, Single exit constructs
Single entry, single exit constructs are control structuresthat enables us to create
sequencing, selection anditeration constructs.
The following are the common single entry, single exitconstructs –
Sequencing Construct
Selection Construct
Iteration Construct
Type 1: while-do looping
Type 2: do-while looping
Type 3: for loop
In cases when we require multiple loop exits, we mayapply go to as some
language allow it or shouldredesign the algorithm to avoid multiple loop
exits,which is the desired practice. Alternatively in suchcases, we may use
the exit or ‘break’ statement asfollows –
while (cond 1){
Code 1;
Code 2;
if (Cond 2){
break;
2. Data encapsulation
Data encapsulation is the process of encapsulating thedata operations of an object
from outside interferenceor misuse. In object oriented languages such as C++, C#
or Java, we implement data encapsulation by classabstractions. In such a case the
class itself doesn’t havephysical existence and is only a logical abstraction.
3. Recursion
A recursive programming style may be applied when theiterative processing may
be indirectly performed byrecursively calling the same program.
.Coding Style
The following are some of the major guidelines thatdictates a perfect codig
style
-DO –
.Use a few standard control constructs –
. Use Gotos in a disciplined manner – G
.Introduce user-defined datatypes to model entities inthe problem domain –
Hide data structures behind access functions. Isolatemachine dependencies
in a few routines
Provide standard documentation prologues for eachsubprogram and/or
compilation unit
.Use indentation, parenthesis, blank spaces, blank linesand borders around
blocks of comments to enhancecode readability
– DONT –
Do not use programming tricks –
. Avoid null-then statement –
Avoid then – if statements
.Avoid routines/methods that causes obscure sideeffects
.Don’t sub-optimize –
. Carefully examine methods/routines having than 5formal parameters
–
. Don’t use an identifier for multiple purposes –.Don’t nest the
loops too deeply –
Documentation
Structured programming constructs, good coding style,meaningful identifier names
to denote user-defined datatypes, variable, enumerators, literals, parameters
canvastly improve code readability and reduce the need forinternal documentation.
Some of the general guidelinesfor internal documentation is as follows –
● Minimize the need for embedded comments byusing
○ Standard prologues
○ Structured programming constructs
○ Good Coding style
○ Descriptive names from the problem domainfor user-defined data
types, variables, formalparameters, enumeration literals,
methods,files etc.
○ Self documenting features of the
implementation language such as
user-defined exceptions, user defined datatypes, data
encapsulation etc.
● Attach comments to blocks of code that
○ perform major data manipulations
○ simulate structured control constructs○ perform
exception handling
● Use problem domain terminology in the comments● Use blank lines,
borders, and indentation tohighlight comments
● Place comments to the far right to documentchanges and revisions
● Don’t use long, involved comments to documentobscure, complex
code, instead rewrite the code● Be sure that the comments and code
agree with
one another and with the requirements and designspecifications.
Coding Standards
General coding standards refers to how thedeveloper writes code, so here
we will discusssome essential standards regardless of theprogramming
language being used.
The following are some representativecoding standards:
1. Indentation: Proper and consistentindentation is essential in producing
easy toread and maintainable programs.
Indentation should be used to:
○ Emphasize the body of a control structuresuch as a loop or a select
statement.
○ Emphasize the body of a conditionalstatement
○ Emphasize a new scope block
2. Inline comments: Inline commentsanalyze the functioning of the
subroutine, orkey aspects of the algorithm shall befrequently used.
3. Rules for limiting the use of global:These rules file what types of data
can bedeclared global and what cannot.
4. Structured Programming: Structured (orModular) Programming methods
shall beused. "GOTO" statements shall not be used as
they lead to "spaghetti" code, which is hard toread and maintain, except as
outlined line inthe FORTRAN Standards and Guidelines.
5. Naming conventions for globalvariables, local variables, and
constantidentifiers: A possible naming conventioncan be that global
variable names alwaysbegin with a capital letter, local variablenames are
made of small letters, andconstant names are always capital letters.
6. Error return conventions and exceptionhandling system: Different
functions in aprogram report the way error conditions arehandled should be
standard within an
organization. For example, different taskswhile encountering an error
condition shouldeither return a 0 or 1 consistently.
Coding Guidelines
General coding guidelines provide theprogrammer with a set of the best
methodswhich can be used to make programs morecomfortable to read and
maintain. Most of theexamples use the C language syntax, but theguidelines
can be tested to all languages.
The following are some representative codingguidelines recommended by
many softwaredevelopment organizations.
1. Line Length: It is considered a good practiceto keep the length of source code
lines at orbelow 80 characters. Lines longer than this maynot be visible properly
on some terminals andtools. Some printers will truncate lines longerthan 80
columns.
2. Spacing: The appropriate use of spaces withina line of code can improve
readability.
Example:
Bad: cost=price+(price*sales_tax)
fprintf(stdout ,"The total cost is
%5.2f\n",cost);
Better: cost = price + ( price * sales_tax )
fprintf (stdout,"The total cost is
%5.2f\n",cost);
3. The code should be well-documented: Asa rule of thumb, there must be at
least one
comment line on the average for everythree-source line.
4. The length of any function should notexceed 10 source lines: A very
lengthyfunction is generally very difficult to understandas it possibly carries out
many various functions.For the same reason, lengthy functions arepossible to
have a disproportionately largernumber of bugs.
5. Do not use goto statements: Use of gotostatements makes a program
unstructured andvery tough to understand.
6. Inline Comments: Inline comments promotereadability.
7. Error Messages: Error handling is anessential aspect of computer
programming. Thisdoes not only include adding the necessary logicto test for
and handle errors but also involvesmaking error messages meaningful.
Data Abstraction
Data abstraction is the programming process of creating a data type, usually a
class, that hides the details of the data representation in order to make the data
type easier to work with. Data abstraction involves creating a representation for
data that separates the interface from the implementation so a programmer or
user only has to understand the interface, the commands to use, and not how the
internal structure of the data is represented and/or implemented.
User defined data types
User-Defined DataTypes:
The data types that are defined by the user are called the derived datatype or user-
defined derived data type.
These types include:
● Class
● Structure
● Union
● Enumeration
● Typedef defined DataType
Below is the detailed description of the following types:
Class: The building block that leads to Object-Oriented programming is a Class. It
is a user-defined data type, which holds its own data members and member
functions, which can be accessed and used by creating an instance of that class. A
class is like a blueprint for an object.
Syntax:
Structure: A structure is a user defined data type in C/C++. A structure creates a
data type that can be used to group items of possibly different types into a single
type.
Syntax:
struct address {
char name[50];
char street[100];
char city[50];
char state[20];
int pin;
};
Union: Like Structures, union is a user defined data type. In union, all members
share the same memory location. For example in the following C program, both x
and y share the same location. If we change x, we can see the changes being
reflected in y.
Enumeration: Enumeration (or enum) is a user defined data type in C. It is mainly
used to a constants, the names make a program easy to read and maintain.
Syntax:
enum State {Working = 1, Failed = 0};
Typedef: C++ allows you to define explicitly new data type names by using the
keyword typedef. Using typedef does not actually create a new data class, rather it
defines a name fo an existing type. This can increase the portability(the ability of a
program to be used across different types of machines; i.e., mini, mainframe,
micro, etc; without much changes into the code)of a program as only the typedef
statements would have to be changed. Using typedef one can also aid in self-
documenting code by allowing descriptive names for the standard data types.
Syntax:
Typedef type name;
wheretype is any C++ data type and name is the new name for this data type.
This defines another name for the standard type of C++.
Concurrency control
Concurrency in software engineering means the collection of techniques and
mechanisms that enable a computer program to perform several different tasks
simultaneously, or apparently simultaneously. This allows for parallel execution of
the concurrent units, which can significantly improve overall speed of the
execution. The base goals of concurrent programming include correctness,
performance and robustness.
