Six steps of Software development life cycle

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.

1. 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.

1. Creating the design

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).

1. 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.

1. 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.

1. 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.

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 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.

Application and Limits of Procedural, Object Oriented and Event Driven Programming

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.

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.
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 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.  

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).

Procedural

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).

Understandability: The code should allow easy interpretation by a different programmer. It should be simple to comprehend as a whole (Brian, 2014).

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).

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).

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.

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.

Object Oriented Programming

In this case jeroo can be named Bobby. The following tasks is expected from Bobby:

Pick the flower

Plant the flower

Jump east

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

Take a right turn and jump two times to plant the flower

Jump East

Take a left turn and jump once

Plant the flower

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 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

“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.

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.

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.
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)

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.

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 ofIsland.

The Second Bulid

This adds the logic for Jane to find John and give him a flower.

The Third build

It adds the logic for John to find and deactivate the net.

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 https://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

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 https://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 https://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

Miller, B., & Ranum, D. (2012). Problem Solving with Algorithms and Data Structures using Python — Problem Solving with Algorithms and Data Structures. Retrieved from https://interactivepython.org/runestone/static/pythonds/index.html

Pal, K. (2018). Software Development Life Cycle: The role of Testing. Retrieved from https://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