SEF9 - 49 Software Construction Principles

(1) Construction Strategies - Hierarchical and Integrated Construction
===========================================================

All multi-tiered software architectures are constructed as both as Hierarchical and Integrated.

A hierarchical organization is an organizational structure where every entity in the organization, except one (top most), is subordinate to a single other entity. This arrangement is a form of a hierarchy. In an organization, the hierarchy usually consists of a singular/group of power at the top with subsequent levels of power beneath them. This is the dominant mode of organization among large organizations; most corporations, governments, and organized religions are hierarchical organizations with different levels of management, power or authority.

The same is with SOFTWARE, it can be a top-down hierarchy, or a bottom-up hierarchy and/or horizontal/lateral hierarchy, that is, in the structure of how software components are being organized. EXAMPLE: We can see this in the BTSS (Bank Teller Simulation System) project.



(2) Class-Based and Modular-Based Construction
===========================================================

Classed-Based construction is basically Object-Oriented Design (OOD) and Object-Oriented Programming (OOP) covering Attributes, Methods, Communications, and many more.

We will see the design such that software "classes" are created as templates to mimic real life entities (for example, in our BTSS project: bank customer, counter staff, ticketing machine, waiting seats, ticket calling display, realtime clock, etc). These classes are then instantiated to become "objects" inside the computer memory. These objects will have "attributes" and "methods". These objects can operate on itself, or operate by communicating through "message passing" with other objects. These object operations can be programmed in a sequential mode or parallel mode. This is what we mean by object-oriented software.

We will see techniques of (1) Abstraction (2) Inheritance (3) Encapsulation (4) Polymorphism and (5) Concurrency.

Modular-Based Construction is essentially construction by breaking complicated functionality into smaller manageable functionality, through modules, where each module performs a specific function. The structure is such that we can independently write modules, modify modules, add modules, remove modules and later integrate all the modules into a complete whole software. They will all fit together.

We have seen modules in many of our python programs (pylab matplotlib module, time module, datetime module, threading module, multiprocessing module, PyQt etc). We can see both Class-Based and Modular-Based Construction in the BTSS project.


(3) Component Based Software Engineering (CBSE)
===========================================================

Modules in many of our python programs (e.g. pylab matplotlib module, threading module, multiprocessing module, PyQt, etc) are also considered as components. But software components must follow some standards like Java standards, Dot Net standards or CORBA standards. If they do not follow the defined standards, the components will not be able to communicate with each other.

There are many more components, for example, plugins (applications) for our web browser, and all multi-tiered software architectures are made out of components. These components are re-usable, sometimes the same components (meaning the same functions) for different programming languages using techniques called wrappers. Directly, it is re-usable even for different applications using the same or different programming languages (wrapping) or through middle-ware and API (Application Programming Interfaces).


(4) Construction for Parallel and Distributed Architectures.
===========================================================

Parallel programming or computing is a form of computation in which many calculations are carried out simultaneously, operating on the principle that large problems can often be divided into smaller ones, which are then solved concurrently ("parallel in time").

A distributed system consists of multiple autonomous computers that communicate through a computer network. The computers interact with each other in order to achieve a common goal. A computer program that runs in a distributed system is called a distributed program, and distributed programming is the process of writing such programs. Google Mail, Google Group, etc, plus facebook are considered distributed applications since they run on different and physically separated computers. Cluster computing and grid computing are considered as distributed architectures.

We will see Parallel Construction (not distributed) in the BTSS project because the simulation requires simultaneous (parallel in time) service transactions between the many bank customers and many bank counter staff, happening at any particular time. We will use the python multiprocessing module for this parallelism.


(5) Aspect-Oriented Programming (Cross-Cutting Concerns)
===========================================================

Similar to object-oriented construction, aspect-oriented construction involves software designed and constructed using the concept of "common aspects" or "cross-cutting concerns" for software entities.

For example, in our BTSS project, we have many instances that we have to "capture" the exact times for the transactions, e.g. (1) time of arrival of a bank customer (printed on the ticket), (2) time the customer ticket get called after waiting in queue, then (3) the time of completion of transactions between the bank customer and the counter staff. These "capture of time" is a common aspect for the three activities (i.e. it cross-cuts the three activities). So, the idea is such that we do not have to write three(3) times the same software code to capture the different times inside the codes for three software objects for those activities. We write a single and separate aspect-code for this. This aspect-code will be used by the three activities. This is what we mean by Aspect-Oriented programming. This common aspect is related to re-usability of software code.


(6) High Integrity Software Codes (control handling, exceptions, etc)
===========================================================

High integrity software is software that is considered as safety-critical or security-critical software. It is just like "a person with high integrity", who is highly principled, incorruptible, not easily influenced, firm, strong and many more. A safety-critical software is software that operates without harming the outside world (causing deaths or loss of lives, property damages, etc,)while a security-critical software is software that operates without allowing the outside world to come in and cause havoc in the software (provides secured operations).

EXAMPLES: Think of the software that control airplanes, control the building lifts, control a nuclear power plant, control all the emergency hospital equipment, etc, as safety-critical software. Think of your bank account software, the military communications software, etc, for security-critical software.

There are special techniques for designing and writing safety-critical or security-critical software. Certain computer programming languages are created specifically for these safety-critical and security-critical software. There are specific published standards for construction of high integrity software.


(7) Source code organization - structure and coding standards.
============================================================

Software have to be organized in some way (i.e. laid out in some logical, efficient, effective and meaningful structure) otherwise it gets dis-organized, messy, difficult to handle, manage, search, operate, maintain, etc, causing confusion and havoc in operation and maintenance. Go to Google or Wikipedia and search for "spaghetti code" or "cowboy coding".

Almost all programming languages provide coding standards and guidelines on how to properly write and organize software codes. Again, go to Google or Wikipedia and search for "List of software coding standards". Make sure to look at "High Integrity C++ Standards". These standards, for example, provides mandatory styles or recommended guidelines for how to write codes into statements, routines, classes, packages, or other structures, etc. The standards explain why you have to follow the styles, its rationale, and even forbid the use of some programming styles. The idea is not just to help programmers avoid errors or potential errors in the software, but also provide advice for achieving correct, safe and secured software.



(8) Code documentation and Code tuning
===========================================================

In software, writing appropriate comments (appropriate, not too little and not too much) in source codes is considered code documentation. Writing "Help Files", "on-line help", API (Application Programming Interface) documents, User Manuals, Design Manuals, etc, are good documentation. Most software coding standards and guidelines provide useful information on what comments to write, how to write the comments, even how to organize the overall documentation, etc.

Code tuning is about writing software codes so that it will run fast and it will avoid potential errors but still meets the functionality intended without fail. An example for code tuning is to write codes as simple as possible, with as very little variables as possible, with as very little number of conditional branching or operations as possible, and as straight forward as possible. Now we are getting into the subject of algorithm theory in software engineering. If we see software codes that are lengthy, think of code tuning as the actions of breaking it up into smaller pieces meeting all the above code objectives.


===========================================================

CASE TOOLS for software construction.

--
WASSALAM
wruslan.hahaha

Microsoft Word Version
Return to Software Engineering Fundamentals (SEF9MMUWRY)
Previous Topic: 48 Reading Materials for Software Testing
Next Topic: 50 Software Construction - What programming language should I use?