Software Design: Principles and Techniques

This article discusses the principles and techniques of software design, including the role of software design in SDLC, six steps of software development life cycle, procedural, object-oriented and event-driven programming, sequence, selection and iteration in computer programming, data abstraction, importance of readability and understandability of code, and quality of code.

Running head: SOFTWARE DESIGN
SOFTWARE DESIGN
Student Name
Student ID
Course
Instructor
Date

SOFTWARE DESIGN 2
Understand the principles of software design
Role of Software Design in SDLC
Software design and development life cycle plays an important role in developing well-
organized applications or programs. The cycle involves a series of steps that must be
followed to create effective and efficient applications (Sinha, 2015). For instance, just like
software development, cooking involves taking some set of steps to prepare the desired food.
The difference between them is that cooking cannot be undone, however bad or good the
food maybe. But programming always allows the developers to go back and update or make
changes to the program (Correla, 2014).
Six steps of Software development life cycle
1. Gathering user requirements
This is the first step of programming. This step involves the programmer collecting the user
requirements. The client explains in detail to the programmer his/her desired requirements
(Jedlitschka & Salo, 2008). User requirements can be aims, subject and the purpose of the
application.
2. Creating specification
This is the second step in development life cycle where the programmer decides on how the
application will be coded according to the client requirements. For example, if it is a website
he needs to specify its functions and aims (Zero, 2017). If the client agrees with the
specifications made by the programmer, the project moves the third step.
3. Creating the design

SOFTWARE DESIGN 3
The programmer outlines how the application should function for it to achieve user’s needs
and its purpose. It can be designing the user interfaces and how various activities will be
linked together before starting to write the actual program (Lui & Chan, 2008).
4. Writing programs
This is the fourth and crucial step of the cycle. When the developer is done with user
specifications, he begins to write the code using a programming language(coding)
(Rajaraman, 2011). In big applications like the FIFA games, developers are divided into
different teams to code on different task and make work easier.
5. Program testing
Program testing involves testing the program to confirm its functionality. If it is working
properly and that it has met all the user requirements. It is done when the coding of the
application is finished (Stair & Reynolds, 2008). In cases of multiple programming teams,
individual programmers test their models then all the programmers come together to validate
and verify the whole program if it is functioning as expected.
6. Maintenance
This the last step of the development life cycle. The programmer checks and correct minor
problems in the application. Fixing can be changing some codes or using some updates.
Application and Limits of Procedural, Object Oriented and Event Driven
Programming
Procedural
Some parts of the program can be divided into smaller pieces of code to perform different
tasks. The smaller parts are called procedures. They divide the program application into
simpler and smaller pieces that are easier to understand. Long lines of code are complex and
hard to understand. For big companies like Google, they use Object Oriented Programming

SOFTWARE DESIGN 4
and procedures to make complex and long lines of code easier to develop their quality
products.
Object Oriented Programming
Object oriented Programming is used in the applications according to the needs the
application was designed for (Information Resources Management Association, 2016). Here,
the developers outline the functions to be applied in the code structure together with the types
of codes. This leads to data structure turning into objects. The objects carry both functions
and data.
Object Oriented Programming
Object Oriented Programming(OOP) splits the program into smaller or mini-programs. The
functions and data of the objects are contained within each smaller program. When you use
objects, it makes it easier for users to understand the project. These objects can be people,
buildings, vehicles or something else that can be used in the application.
Data Abstraction and Encapsulation, Classes, objects, Inheritance and polymorphism are the
elementary concepts of OOP.
Classes: A class contains a group of related objects. Numerous objects can therefore be
created in the same defined class.
Objects: Objects are run-time entities as far as OOP is concerned. Objects and the type of
communication between them are used in the analysis of a problem. These objects interact
with one another by sending requests when the program is run. Also They do not need to
know the data or code of other objects to interact.
Inheritance: when the objects takes the properties of objects from other classes, it is said to
have inherited the properties. Inheritance enables the programmer to reuse the same code by
adding some features to it and not modifying the entire class. It is achieved by using the
existing classes to derive new ones.

SOFTWARE DESIGN 5
Data Abstraction and Encapsulation. Data abstraction is used to represent different
features of the of the program without using the background or code explanations. Classes
abstract attributes list from the concept of abstraction.
Encapsulation is the process of storing data and methods in a single class. The stored data
cannot be accessed or used outside the class. Only the methods or functions stored inside that
class can use them.
Polymorphism: Polymorphism is taking more than one form the same function or method.
An operation may display different characteristics in different instances of the object. The
data types used in the program or operation are the ones that manipulate the behaviour.
Polymorphism is widely used to implement polymorphism.
Advantages of object-oriented programming
1. Code maintenance and modification is easy. Existing codes can be used to create new
objects having small differences from the original ones.
2. It provides a good framework for libraries of the code where by adaptation and
modification of the software components can be easy. Object oriented programming is
also useful in creating the user interfaces.
Event driven Programming
Functions are a collection of pieces of code doing a given task. They break down large
programs to much simpler and smaller programs that are easier to manage. No writing of
code again and again because they make the code reusable. Functions can be Built-in or User-
defined functions.
Built-in functions: These are functions that are not accessible by the user. They are designed
by the programmer and can only be contained in the program.
User-defined functions: The user designs and programs them. These functions can be
different in terms of names and the requirements of the coder.
Advantages of event-driven programming
1. It is used to create very interactive applications. Event driven programming is almost
used in every Graphical User Interfaces (Koumpis, 2012). Example of an event driven
programming language is JavaScript.

SOFTWARE DESIGN 6
2. Hardware interrupts can be used to implement event-driven programming which
minimizes power consumed by the computer.
3. Event-driven programming allows sensors and other hardware to interact easily with
software. No predefined method in procedural programming to take care of sensors
event which therefore needs a written function. The function is more complex than
using event-driven programming (Heijden, 2009).
Sequence, Selection and Iteration in Computer Programming
Sequence is the right commands in the right order
Selection is when you choose at most one option or action when several alternatives are
available or conditions exist.
Iteration is where statements or a block of statements are repeated if the condition is true and
still exist.
Data Abstraction Computer Programming
Abstraction mentions to the act of representing required features without including the
background details or explanations of the code (Pal, 2018). Classes use the concept of
abstraction and defines a list of abstract attributes. Storing data and functions/methods in a
single class (unit) is called encapsulation i.e. that data or code unit cannot be accessible to the
outside the class or the world and only those functions/methods which are stored in the class
can only access them (Declan, 2014).
Importance of The Readability and Understandability of Code
Readability: Some companies that develop applications have their own set standards that
programmers are required to follow (Awatare, 2014). In situations where many programmers
are coding one application, they must use comments to enable other programmers to
understand the code with ease and to provide more information. Comments are not compiled
with the code; they are ignored by the compiler. It only makes easier to read and understand
the code (Baskin, 2018).

SOFTWARE DESIGN 7
Understandability: The code should allow easy interpretation by a different programmer. It
should be simple to comprehend as a whole (Brian, 2014).
Quality of Code
The quality of code has six vital parts, efficiency, reliability, robustness, usability, portability
and maintainability (Rodríguez, 2018). They are discussed in detail below.
Efficiency: the code should ensure there is minimal utilization of system resources
Reliability and robustness: A reliable and robust program is a program that is able to show
error messages or able to solve the problem instead of crushing and stopping working
(Rajaraman, 2011). For instance, when you search for something using Google, then you
misspell a word like Goantanamo instead of Guantanamo, the program will not crush but it
will run and give the suggestions of the correct word. Hence, the programs should be
developed and tested to meet such standards.
Usability: Good programs are intuitive. They are designed in a way that they can be easily
learnt and easily used. Applications can be made easier to use by:
 Labeling controls
 Arranging controls logically
 Using user-defined functions
Maintainability: the code should allow for modification to improve performance, add
capabilities, and correct errors.
Portability: the code should allow modification so as to be executed in different environments
(operating systems).

SOFTWARE DESIGN 8
Apply the techniques of software design
Introduction
This section will discuss problem representation through algorithm development. Secondly, it
will identify and define requirements of storage of file and data storage including data items
that are predefine. Thirdly, program structures and predefined code items will be identified
and defined. Fourthly, Input and output identification and representation. Finally, Software
design will be expressed by use of pseudocodes and program codes.
An algorithm basically means the steps and step by step procedures taken to solve a problem
(Kuchling, 2012). There exist several methods and techniques of writing algorithms, they can
be formal or informal an is represented either graphically or mathematically. An algorithm
can easily be translated into a computer program once developed. There exist five main steps
of developing an algorithm. They include, problem description, problem analysis, high-level
algorithm development, algorithm refinement, and algorithm review (Miller & Ranum,
2012).
Problem Description
A Jeroo begins at (0,0) looking in the east direction and its pouch does not have any flower.
The flower can be found in location (3,0). The problem here is to direct Jeroo to pick the
flower from location (3,0) and take it to location 93,2) to plant it. Afterwards Jeroo should
jump one box east and stop. The highland has no other flowers, Jeroo, or nets. The task is to
write a program to solve the above problem.
Start Finish

SOFTWARE DESIGN 9
Problem Analysis
We can see the location of Jeroo to be exactly three steps behind the flower. Jeroo is to plant
the flower exactly two boxes south of the location it is currently. After planting the flower
jeroo is to move one box east to finish the task. Nets are not there as such its nothing to worry
about.
High-Level Algorithm Development
In this case jeroo can be named Bobby. The following tasks is expected from Bobby:
Pick the flower
Plant the flower
Jump east
Algorithm Refinement
Jeroo can be named Bobby. Bobby is expected to do the following:
Take the flower
Jump three times
Get the flower
Place the flower in its pouch

SOFTWARE DESIGN 10
Take a right turn and jump two times to plant the flower
Jump East
Take a left turn and jump once
Plant the flower
Algorithm Review
The problem has been broken down into three simple subproblems by high-level algorithm
which is a good technique. The algorithm is designed to solve the specific problem because
both the flower and Jeroo are in specific location. However, the solution rather solves a more
or less general problem whereby Jeroo and the flower located three jumps directly in front of
Jeroo.
The solution
The solution will be developed using Java and in several builds until the ideal solution is
determined. Every successive build improves the previous one. We will be guided by high-
level algorithm.
First Build
Greenfoot4Sofia scenario will be created in order to see the solution in action. Edit Palettes
and Jeroo menu commands will be used to ensure that Jeroo classes are visible.
Second Build

SOFTWARE DESIGN 11
“Get the flower” logic will be added to build one
Third Build
“Put the flower” Logic will be added to the second build.
Forth Build
“Hop East” logic will be added to the third build.

SOFTWARE DESIGN 12
Example 4.2: Replacing the Net with Flower
This part has the second example to demonstrate the process of algorithm development.
Step 1: Statement of problem
There are two Jeroos at different locations. Both have one flower on their pouch. The first
one is at point (0,0) facing North while the second one is at coordinate (0,2) facing East. A
net is located at point (3,2). You are supposed to write a code that guides the first Jeroo to
take its flower to the other Jeroo. The second Jeroo has to disable the net and plant a flower
in its place after receiving the flower. The second Jeroo must turn to South after planting the
flower. Note that there are no other Jeroos, Nets or Flowers located on the Island.
Start Finish
Step 2: Analyzing the problem
1. Jeroo_1 is exactly two spaces ahead of Jeroo_2.
2. Jerro_2 is exactly three spaces behind the only net on the island.
3. Both Jeroos have only one flower.

SOFTWARE DESIGN 13
4. Jeroo_1 gives the flower to the Jeroo_2 to make it two. Jeroo_2 uses the one flower to
disable the net while the second one is planted at point (3,2), where the net is.
5. Jeroo_1 finishes facing South at point (0,1).
6. Jeroo_2 finishes facing South at point (3,2).
7. Since one of the flowers was planted and the other one used to disable the net, the
Jeroos will finishing with no flowers on their pouches.
Step 3: High Level Algorithm
We name the first and second Jeroo Jane and John respectively.
Jane should find John and should not collide with him. She must give the flower to
John(being straight ahead).
John should do the following after receiving a flower from jane:
Find the location of the net and should not step onto it
Deactivate the net
Plant the flower where the net’s location
Then he should face South
Step 4: Detailed Algorithm
We name the first and second Jeroo Jane and John respectively.
The functions of Jane will be:
To find the location of John.
Turn left or right twice.
Hope to point (0,1)

SOFTWARE DESIGN 14
Submit the flower to John.
Give ahead
After john receives the flower, he should do the following:
Get the net’s location
Go to point (2,2)
Deactivate the net
Toss
Plant a flower at the net’s location
Go to location (3,2) and plant a flower
Face south
Turn to right
Step 5: Reviewing the Algorithm
1. High-level algorithm is used to manage the details.
2. The algorithm attempts to solve a specific problem. In this algorithm the specific
locations are not vital. The starting point of Jeroos relative to the other one and the
net’s location relative to the location of the second Jeroo and direction is important.
Java Code to Replace the net with Flower
As previously, write the code incrementally as a series of builds. For this problem, four builds
are appropriate. Declaration of Jeroos, instantiation of their objects and comments of the
high-level algorithm are contained in the first build. Jane gives John the flower in the second
build. John will find and deactivate the net. John has to replace the flower and turn to East in
the last build.

SOFTWARE DESIGN 15
The First Build
The first build contains the main method, instantiates the objects of the Jeroos and should
outline the high level algorithm. myProgram() will be the main method for this example and
a subclass of Island .
The Second Bulid
This adds the logic for Jane to find John and give him a flower.

SOFTWARE DESIGN 16
The Third build
It adds the logic for John to find and deactivate the net.

SOFTWARE DESIGN 17
The Fourth build(last)
It adds the logic for John to place a flower at point (3,2) and he turns to South.
References
Awatare, A. (2014). Event oriented programming. Retrieved from
https://www.slideshare.net/ashwiniawatare/event-oriented-programming
Baskin, K. (2018). How to use algorithms to solve everyday problems. Retrieved from
http://mitsloan.mit.edu/newsroom/articles/how-to-use-algorithms-to-solve-everyday-
problems/
Bourne, K. C. (2014). Application administrators handbook: Installing, updating and
troubleshooting software

SOFTWARE DESIGN 18
Brian, E. (2014). what is the relation of event-driven programming and object-oriented?.
Retrieved from https://stackoverflow.com/questions/22101731/what-is-the-relation-of-
event-driven-programming-and-object-oriented
Correla, G. (2014). Importance of SDLC | THE FAS SOLUTIONS – Quality Software
Development | High Quality Software Solutions |. Retrieved from https://thefas-
solutions.com/2010/08/13/importance-of-sdlc/
Declan, V. (2014). Programming Paradigms (Unit 6). Retrieved from
http://declansprogrammingparadigms.blogspot.com/
Heijden, J. G. M. (2009). Designing management information systems. Oxford: Oxford
University Press.
Information Resources Management Association. (2016). Web-based services: Concepts,
methodologies, tools, and applications
Jedlitschka, A., & Salo, O., (2008). Product-focused software process improvement: 9th
international conference, PROFES 2008, Monte Porzio Catone, Italy, June 23-25, 2008.
Berlin [etc.: SpringerLink [host.
Koumpis, A. (2012). Management information systems for enterprise applications: Business
issues, research and solutions. Hershey, PA: Business Science Reference.
Kuchling, K. (2012). Background: Algorithms — 50 Examples 1.0 documentation. Retrieved
from http://fiftyexamples.readthedocs.io/en/latest/algorithms.html
Lui, K. M., & Chan, K. C. C. (2008). Software development rhythms: Harmonizing agile
practices for synergy. Hoboken, N.J: Wiley-Interscience

SOFTWARE DESIGN 19
Miller, B., & Ranum, D. (2012). Problem Solving with Algorithms and Data Structures using
Python — Problem Solving with Algorithms and Data Structures. Retrieved from
http://interactivepython.org/runestone/static/pythonds/index.html
Pal, K. (2018). Software Development Life Cycle: The role of Testing. Retrieved from
http://mrbool.com/software-development-life-cycle-the-role-of-testing/29838
Rajaraman, V. (2011). Analysis and design of information systems. New Delhi: PHI Learning
Rodríguez, J. (2018). Retrieved from https://www.quora.com/What-is-the-difference-
between-object-oriented-and-event-driven-prrogramming
Sinha, V. (2015). Role of SDLC in Effective Software Development. Retrieved from
https://www.synapseindia.com/role-of-sdlc-in-effective-software-development/378
Stair, R. M., & Reynolds, G. W. (2008). Principles of information systems: A managerial
approach. Boston, Mass: Thomson/Course Technology.
Zero, V. (2017). Software Development Lifecycle Process. Retrieved from
https://www.mdt.mt.gov/research/projects/app_dev/SDLC/SDLC.SHTML