Structured Programming and Procedural Programming

Top-down analysis - A software is always made to perform some rational work. This rational work is known as a problem in software parlance. Thus, it is very important that we understand how to solve the problem. Under top-down analysis, the problem is broken down into small pieces where each one has some significance. Each problem is individually solved and steps are clearly stated about how to solve the problem.

Modular Programming - While programming, the code is broken down into a smaller group of instructions. These groups are known as modules, subprograms, or subroutines. Modular programming based on the understanding of top-down analysis. It discourages jumps using 'goto' statements in the program, which often makes the program flow non-traceable. Jumps are prohibited and modular format is encouraged in structured programming.

Structured Coding - In reference to top-down analysis, structured coding sub-divides the modules into further smaller units of code in the order of their execution. Structured programming uses control structure, which controls the flow of the program, whereas structured coding uses control structure to organize its instructions in definable patterns.

First class and High-order functions - These functions have the capability to accept another function as an argument, or they return other functions as results.

Pure functions - These functions do not include destructive updates, that is, they do not affect any I/O or memory and if they are not in use, they can easily be removed without hampering the rest of the program.

Recursion - Recursion is a programming technique where a function calls itself and repeats the program code in it unless some pre-defined condition matches. Recursion is the way of creating loops in functional programming.

Strict evaluation - It is a method of evaluating the expression passed to a function as an argument. Functional programming has two types of evaluation methods, strict (eager) or non-strict (lazy). Strict evaluation always evaluates the expression before invoking the function. Non-strict evaluation does not evaluate the expression unless it is needed.

λ-calculus - Most functional programming languages use λ-calculus as their type systems. λ-expressions are executed by evaluating them as they occur.

Naming conventions - This section defines how to name functions, variables, constants, and global variables.

Indenting - This is the space left at the beginning of a line, usually 2-8 whitespace or single tab.

Whitespace - It is generally omitted at the end of a line.

Operators - Defines the rules of writing mathematical, assignment, and logical operators. For example, assignment operator '=' should have space before and after it, as in "x = 2".

Control Structures - The rules of writing if-then-else, case-switch, while-until, and for control flow statements solely and in a nested fashion.

Line length and wrapping - Defines how many characters should be there in one line, mostly a line is 80 characters long. Wrapping defines how a line should be wrapped if is too long.

Functions - This defines how functions should be declared and invoked, with and without parameters.

Variables - This mentions how variables of different data types are declared and defined.

Comments - This is one of the important coding components, as the comments included in the code describe what the code actually does and all other associated descriptions. This section also helps in creating help documentation for other developers.

Requirement documentation - This documentation works as a key tool for software designers, developers, and the test team to carry out their respective tasks. This document contains all the functional, non-functional, and behavioral descriptions of the intended software.

The source of this document can be previously stored data about the software, already running software at the client's end, client's interview, questionnaires, and research. Generally, it is stored in the form of a spreadsheet or word processing document with the high-end software management team.

This documentation works as a foundation for the software to be developed and is majorly used in the verification and validation phases. Most test cases are built directly from requirement documentation.

Software Design documentation - These documents contain all the necessary information, which is needed to build the software. It contains: (a) High-level software architecture, (b) Software design details, (c) Data flow diagrams, (d) Database design

These documents work as a repository for developers to implement the software. Though these documents do not give any details on how to code the program, they give all the necessary information that is required for coding and implementation.

Technical documentation - These documents are maintained by the developers and actual coders. These documents, as a whole, represent information about the code. While writing the code, the programmers also mention the objective of the code, who wrote it, where it will be required, what it does and how it does, what other resources the code uses, etc.

The technical documentation increases the understanding between various programmers working on the same code. It enhances the re-use capability of the code. It makes debugging easy and traceable.

There are various automated tools available and some come with the programming language itself. For example, java comes with a JavaDoc tool to generate technical documentation of code.

User documentation - This documentation is different from all the above explained. All previous documents are maintained to provide information about the software and its development process. But user documentation explains how the software product should work and how it should be used to get the desired results.

These documents may include software installation procedures, how-to guides, user guides, uninstallation methods, and special references to get more information like license updates, etc.

Code-reuse - Programming interfaces of present-day languages are very sophisticated and are equipped with huge library functions. Still, to bring the cost down of the end product, the organization management prefers to re-use the code, which was created earlier for some other software. There are huge issues faced by programmers for compatibility checks and deciding how much code to re-use.

Version Management - Every time new software is issued to the customer, developers have to maintain version and configuration related documentation. This documentation needs to be highly accurate and available on time.

Target-Host - The software program, which is being developed in the organization, needs to be designed for host machines at the customers' end. But at times, it is impossible to design a software that works on the target machines.