Lecture: III

Course Title: Software Development Ecosystem

Course Code: CPE201
January 9, 2023

1 Introduction
Hardware cannot perform efficiently without the software. Software makes the com-
puter to run. Software is a program or set of instructions that enables the
computer to do a specific task. On the other hand, computer is use to develop the
software. Software engineering refers to the creating of instructions for computer,
the computer functions based on these instructions, these instructions are executed in
the processor and the microcontroller present on the computer motherboard. Software
is often used to describe all the functional aspects of a computer that do
not refer to its physical components (hardware). Scripts, applications, pro-
grams and a set of instructions are all terms often used to describe software.
Understanding the software development method offers vast opportunities in the IT in-
dustry.

Software development is the process engineers take to build computer programs. This
process is also known as the Software Development Life Cycle (SDLC). This includes
several phases that provide a method for building products that meet technical specifica-
tions and user requirement. The SDLC is a comprehensive tool for solving organizational
problems, particularly those relating to the flow of computer-based information. SDLC
process are what many organizations follow during systems analysis and design, the pro-
cess are:

(i) preliminary investigation

(ii) systems analysis

(iii) systems design

(iv) systems development

(v) systems implementation

(vi) systems testing & debugging

(vii) systems maintenance.

1
 **PLEASE READ MORE ON THE SIX PROCESS ABOVE**

Phases often overlap, and a new one may start before the old one is finished. After the
first (iv) phases, management must decide whether to proceed to the next phase.

Figure 1: Software development ecosystem by Boguslaw Cyganek)

In Fig:1, to execute software written in C++, it needs to be translated by the com-

piler into a machine representation. Since software can be created in parts and can use
previously created libraries, all of them need to be joined into one executable. This is
done by the linker. These are the software build stages. Next, the executable needs to
be properly tested and debugged to remove malfunctions. Then, the operation of the
current version can be further optimized by launching the profiler. Its role is to measure
the performance of software components to discover hot spots – code fragments that con-
sume the most execution time. After that, the entire software development process can
be repeated to build the next, better version. During this process, we cannot forget to
protect and control the versions of our software. This can be accomplished by using a
source control and versioning platform. After the software is ready, it can be deployed
on a concrete hardware platform.

This process of translating from the C/C++ language is done by a program commonly
known as a compiler. Shoulder to shoulder with operating systems, compilers are very
com- plex and sophisticated programs, as we will have many occasions to observe.

In the C++ environment, software components can be created independently; and to

build a final program, these pieces need to be joined together. This task is performed by
a linker as shown in fig:1. After its successful operation, we have a code component that

2
can be executed by a computer.

Since even short programs can implement complicated concepts, we should have no illu-
sion that we will write the correct version from the very beginning. Therefore, we should
also write software that controls what other software is doing. This can be, for instance,
in the form of unit tests, which we will also discuss. When problems are spotted in soft-
ware, it can be run step by step with a debugger. Debugging is the best way to learn
what code is doing.

Software can have different configurations and versions. Although many configurations
are possible, usually there are two distinctive modes:

• Debug: A software version that usually is not optimized and is used for “in house”
testing and debugging

• Release: A stable version of the software after intensive testing, which is fully
operational, optimized, and intended to be distributed to users

In many cases, performance still is not satisfactory due to long execution times or stalls.
This can be amended with the help of a profiler. Its role is to measure the perfor-
mance of software-building components and discover hot spots at different levels. Such
reported places in the code i.e. those that consume the most execution time can be
further optimized with the help of other algorithms or refactoring (i.e. redesigned and
re-implemented) into a parallel version, if possible. After that, we can repeat the entire
software development process in order to build the software’s next, better version.

After the software is ready, it can be deployed on a concrete hardware platform. A de-
gree of soft- ware-hardware (S/H) dependence is a function of software features. That
is, some programs can easily run on almost any hardware platform, whereas others may
require significant computational power or can be tuned for specific displays, for instance.
Hence, if appropriate, such features need to be taken into account during the software
development steps.

2 Software Development Steps

Just as there is more than one way to design a house, a bridge, or a car, there is also
more than one way to design software. However, in all of these cases, the ultimate
criterion indicating success or failure is the performance of the final product. As in other
engineering fields, based on years of experience and thousands of projects, some common
rules can be recognized that help us avoid common pitfalls in future designs. The process

3
involved in the software development process is stated in fig:2 Although C++/Rust is

Figure 2: UML activity diagram presenting the steps of the software development process.
Boguslaw Cyganek)

our main subject, we will also pay attention to other software development steps. Let’s
describe each of them briefly in the order shown in fig:2

1. Requirements specification – A process of defining the main tasks to be solved,

as well as func- tionality and applications of the product. Involves cooperation
between many parties, such as end users, system architects, managers, etc.

2. Problem analysis – Based on the previous step: the process of establishing the
main relations in the system, recognizing the governing rules of the critical system
processes, identifying the most difficult components, and sketching the main stages
of the critical algorithms with special focus on the most problematic ones. In some

4
 cases, this can be one of the most expensive and tedious steps, involving experts
from other domains.

3. Solution design – Based on the previous steps: the process of specifying the
architecture of the whole system, considering all of its components and their inter-
faces. Includes specification of tools and implementation strategies. Frequently, this
process involves the preparation of Gantt charts that capture inter-dependencies be-
tween system implementation stages, human resources, deadlines, and milestones.

4. Implementation – The process of software creation based on the previous steps.

The main product of this stage is the source code.

5. Testing and debugging – Joint processes of discovering and fixing malfunction-

ing software. Tests should be well designed using formal methodologies such as
test-driven development (TDD) and unit testing. However, problems arise when a
malfunctioning implementation is due to flaws in the design or other upper levels
of the development process. Therefore, the role of the design steps is paramount.

6. System deployment – The process of system integration and installation to en-

sure proper operation on a specifically configured hardware platform. This usually
requires adjustments to specific hardware components that, for example, are miss-
ing or have different parameters

7. System maintenance – The practice of ensuring uninterruptable system operation

and allowing for system evolution and seamless system changes.

The software development steps discussed above are not the only possible path to follow
in this highly demanding engineering domain; they are simply one of the possible models.
Design strategies developed in other domains, such as electronics and architecture, can
also be of help in software design.

The previous steps should also be reflected in the project documentation, the structure of
which could be the topic of a much longer discussion. Needless to say, such documentation
should as precisely and concisely as possible describe all the steps necessary to solve a
given problem. In our projects, we will deal mostly with code documentation. In this
respect, the principle of self-docu- menting code has proven useful in many practical
realizations. This is based on the assumption that proper comments are added during
software implementation.

5
Please Note: releasing this material out for you is not the main

important things for not coming to class. Is from the class we

discuss the main problems behind them, even with examples.