Software Engineering Overview

By | February 6, 2019

What is Software Engineering?

Software engineering is a branch of engineering which is associated with design, development and maintenance of software.

In a nutshell we start software development by selecting a process. The process can have several phases. Each phase can have several activities. Each activity can be further break down into smaller tasks and execute them to develop as successful software.

So we can say that

“A software development happens by following a process. A process is made up of different phases. A phase is made up of different activities. An activity is made up of different tasks.”

In this post we will give an overview about-

  • Key principles of Better Software
  • How to measure the success of a software product
  • Four Principles of Software Construction
  • Software Engineering Process
  • Common Phases of a Process in Software Engineering
  • Common Activities of each phases under a Process of Software Engineering
  • Tasks in Software Engineering Activities

Key principles of Developing Better Software

Every software developer /engineer wants to develop great software. But developing great software requires sustained work of many people with different skillsets. Great software has few viewpoints/goals whose are-

1. Develop the right Software product

This viewpoint says that “Develop right software for clients”.

But how can know that our developed software is the right product for our client? Is there any way to know that?

Answer is yes.  If our software meets client needs, solves all client problems and clients are happy with that software then we can say that we developed right software product.

By achieving this viewpoint we actually validated our product.

2. Software product done right

This viewpoint says that “make sure that you have done the right thing”.

How can we make sure that?

We can make sure by “implementing all specified designs into the software” and “ensure that each specified design meets a set of requirements” ..

The developer will conduct the review and test to make sure them.

By achieving this viewpoint we actually verified our software product.

3. Software product managed right

This viewpoint says that “make sure that our software is well manageable”.

How can we make sure that?

  • By adopting suitable processes and practices to organize our works
  • Better communication between team members, better communication with clients & continuous feedback. It makes everyone clear about next steps.

By achieving this viewpoint we actually make our software well managed.

How to Measuring Software Project Success

Software product success measures by following things-

  • On-time delivery
  • Completed within budget
  • Delivered with all features completed

There is also some additional success measurement criteria’s are-

  • The number of post release bugs
  • The support needed after a release
  • Customer rating on software
  • The revenue generated by that software
  • Client’s satisfaction

 Four Principles of Software Construction

There are four fundamental principles/pillars that can that can affect the way of software construction they are –

  • Reduction of complexity
  • Anticipation of diversity
  • Structuring for validation
  • Internal or external standers

 Reduction of complexity

Building software which is easier to understand and use.

Anticipation of diversity

Software should be able to anticipate with any changes whether it comes expected or unexpected way.

Structuring for validation

  • It is also known as design for testability.
  • Design and build software in such way so that it can easily tests during verification and validation activities.

Internal or external standers

Confirm a set of internal and external standards for specific domain.

Internal standards

Coding standards or naming standards within an organization.

External standards

Some regulations and standards those are valid of that specific domain.

Example-

Suppose we are developing some medical software. There are some regulations and some standards that you have to adhere to in order for your software to be valid in that domain.

 Software Engineering Process

To develop software we have to follow a process. Process is the key starting point of developing any software product. A process organizes the work on a software product into distinct phases. The work will transition from one phase to another phase. This is also known as software development life-cycle.

Types of Process Models

Adopting and adapting a suitable process is the key in structuring the work for a successful project. There are many process models that have already been used successfully. Based on the nature of the project we can follow anyone among them.

Based on the execution nature of the process phases we can categorize process models into three types whose are-

a- Linear process model

Phases that happen sequentially, one after another e.g. – Waterfall Model, V-Model

Iterative process model

Phases that are repeated in cycles e.g. – Spiral Model

Parallel process models

Activities that occur concurrently e.g. – Unified Process Model

Common Phases of a Process in Software Engineering

A process contains several phases/stages. Common software development stages are

  • Specification
  • Design & Implementation
  • Validation and verification

Specification Phase

Specification phase is the starting point of any software development process. In this phase we focus on the requirements of the product.

  • In a linear process model specification activities might happen once at the beginning of the process
  • In iterative or parallel process model specification activities can be revisited multiple times to capture updated client needs and suggested product improvements.

 Design & Implementation Phase

This phase starts after completion of the analyzing of requirements. In this phase we generally focus on structuring & organizing the system. After designing and organizing of the system we will start implementing of that design into actual software system.

  • In linear process model the design and implementation activities might  happen once at the beginning of the process
  • In iterative or parallel process model design & implementation activities can be revisited multiple times to capture updated client needs and suggested product improvements.

Verification & Validation Phase

After we have built our system verification and validation is that phase of software development that aims to check that that software system meets the specification and fulfill its intended purpose. More precisely we can look at verification and validation independently.

 Verification

Verification answers the different question which is-

i. Did we build the system right?

ii. Did we build the system that actually implements the specification that we defined?

Verification can be performed at different levels. In particular

a-It can be performed at unit level i.e. we test each unit of work as we expected

b- It can be performed at integration level i.e. we test the interaction between different units and make sure that the different modules talk to each other in the right way.

c- It can be performed In the system level i.e. test the whole system and make sure that entire system, all different pieces of the system work together in the right way. At this level we will also apply validation and some other testing techniques like stress testing, robustness testing and so on.

 Validation:

Validation is the activity that answers the question-

i- Did we build the right system?

ii-Did we build the system that customers want?

iii-Did we build the system that will make our customer happy?

Common Activities of each phase under a Process of Software Engineering

As we know in software development we have several phases. In each phase/stage of a process we do some activities. So we divide each phase into different activities-

For example Executing Test is an activity of Validation and Verification phase.

We do some activity in every phase of a process. We already know the common phases of a process. Now we’ll see the common activities of each phase whose are includes-

  • Activities of Specification Phase
  • Activities of Design & Implementation Phase
  • Activities of Verification & Validation Phase

Activities of Specification Phase

Identifying product ideas or needs

Thoroughly understand the idea/need of the product. It drives the development process to create a great software product

Eliciting Requirements

Discover requirements, by interacting with users, clients, and other stakeholders, investigating their needs, and exploring the ideas and features of a potential product

Expressing Requirements

Write requirements in structured way

Prioritizing Requirements

Organize the list of requirements based upon what is of higher value and should be completed earlier.

Analyzing Requirements

Examine the requirements of a product to ensure, for example, that they are clear, complete, and consistent

Managing Requirements

Organize, Reuse and Reference each requirement

Formulating Potential Approaches

Outline a strategy, considerable alternatives, further refine next steps

Activities of Design & Implementation Phase

These are activities accomplished by the development team to design and implement the software product. Design and implementation activities can include:

  • designing the architecture
  • designing the database
  • designing interfaces
  • creating executable code
  • integrating functionality
  • documenting

Design of software architecture, databases, and interfaces will improve the ability of developers to work together towards a common goal.

Once programming begins, programmers should write code, integrate or combine their code at regular intervals to ensure that they have completed some functionality.

Internal documentation will help new developers when they join the team or enable existing team members to work on development of unfamiliar aspects of the product.

Activities of Verification & Validation Phase

Constant verification and validation of the product will ensure that its development is on the right track.

Verification and validation activities include:

  • developing test procedures
  • creating tests
  • executing tests
  • reporting evaluation results
  • conducting reviews and audits
  • demonstrating to clients
  • conducting retrospectives

Verification’s are actually internal testing and technical review. It ensures what is needed to do as per documented design and requirements. Verification answers following different questions-

  • Did we build the system right?
  • Did we build the system that actually implements the specification that we defined?

Verification can be performed at different levels. In particular verification can performed at-

  • Unit Level

Test each unit of the system works as expected e.g. – Unit Testing

  • Integration Level

Tests the integration between different units and make sure that different modules talk to each other in the right way e.g. – Integration Testing

  • System Level

Test the whole system and make sure that entire system work in the right way. At this level we will also apply validation and some other testing techniques like stress testing, robustness testing and so on.

Validation ensure

  • Did we build the right system?
  • Did we build the system that customers want?
  • Did we build the system that will make our customer happy?

Tasks in Software Engineering Activities

We perform each activity by executing one or more tasks. For example to performing Executing Test activity we can execute following tasks-

  • Writing Test Cases
  • Writing Test Code
  • Run Test for each individual cases

Tasks are where real world work gets done. Tasks are small, manageable units of work for the project gets done. Tasks are the basic building block for completing an activity, finishing a phase and completing a process.

So in shortly we can say

“Each process builds upon several phases/stages. In each phase we perform some activities by executing one or more tasks.

Task & Task Dependencies

Tasks are the more basic unit of work. In other word we can say Tasks are the small pieces of work. In software development tasks are like as follows-

  • Writing source code for view all employees
  • Design an UI for view all employees
  • Test the feature “View all employees”

Tasks often have dependencies. Sometime a task depends on the completion of another task. From above task list our “Test the feature” task depends on “Writing source code for view all employees” and “Design UI for employee list” tasks because if no data and no UI what should we test?

So identifying dependencies and task ordering is important fact. Without properly ordering of tasks there much possibility to developer chooses a task that is dependent on another task and that task is not yet completed. So that the developer will stuck at that place, and work will be hampered. For example- if the developer choose the task of testing the feature of “View all employees” before writing functionality and designing UI for relevant task then the user will not be able to execute that task and he/she will stuck at that place and work will hampered.

Roles

A role is a job which is related to the activity assigned to a person.

Example

Jack is a software engineer. One of his role is write program for develop the software.

A development team will have multiple members who have different roles like-

  • Graphics Designer
  • Programmer
  • Tester
  • Project Manager
  • Product Owner
  • Scrum Master

Each role on a team describes specific skills. Role will need to accomplish any given task.

Example:

  • Kathy is a Graphics designer. In this case Kathy’s role is graphics designing. This role also says that Kathy has enough skills in graphics design and she is capable to accomplish any graphics design related works.
  • Jack is a programmer. In this case Jack’s role is programming. This role also says that jack has enough skills in programming and he is capable to writing code to develop a feature
  • Jenny is a tester. In this case Jenny’s role is testing any developed feature from different aspects. This role also says that Jenny has enough skills in testing and she is capable perform any type of software tests.

Tasks is performs by Roles

Task will execute by the people. Though within a team every people has specific role (relevant to his/her skills and expertise) so it is good practice to assign a specific task to a role instead assign to specific person.

Example-

  • “Writing code for certain feature” is a Task. We’ll assign the task to programmer role. There are three programmers in the team (Jack, Jenny and John). Due to assigning task to role anyone among them can execute the task.
  • Testing the feature that developed by the team also another task. It will be assigned to Tester. Sam and Alex is the Tester in this team. Due to assigning task to role anyone among them can execute the task.

There are few good reasons of assigning tasks to role instead of assigning to specific person. They are-

  • A person of an organization can change at any time. So assigning a task to a role is more constant over the life of the project.
  • Setting task to a roles will help avoid any personal choices that can occur when assigning tasks to specific people instead of a given role

So in summary we can say that “A role performs a task”.

Tasks produce Working Products

The output produced by completing a task is actually a work product. Work product can be

  • Design Documentation
  • Requirements documents
  • Source code
  • Test Cases
  • Project Management artifacts like status reports

 In-fact final product is also a work product.

Since work products are the outputs of tasks, so we can say that-

“A task produces a work product”

 So we will break down our task in such way so that every individual task produces a work product. Otherwise task in some cases tasks can be meaningless.

Working Products i.e. Output of a Task can be the Input of its Dependent Task

As we know work product is the output of a task. However this output can be input for another task. How?

We already saw some tasks have dependencies on other tasks. In those cases work product output of an earlier task will also be the input for a subsequent task.

Example:

The output of a task of “design a feature” becomes the input for the task “writing source code for that feature”

Tasks require Resources to complete

Completing any given task requires resources like time, people, technology, knowledge, and money. So we can say “A task consumes resources”

 

Now we have an overview of “Process”, “Phase/Stage”, “Activity” & “Task” those are closely related to develop any software product. Simply we can say that-

A process is made up of phases. A phase is made up of activities. An activity is made up of tasks.

15 Total Views 1 Views Today
Md. Mojammel Haque

CSM, CSPO, CSD, CSP-SM, CSP-PO (ScrumAlliance.org)
Certification Profile Link-
https://www.scrumalliance.org/community/profile/mhaque13

Currently working as Lead Team (Application Architecture) at Raven Systems Ltd. Passion for software development especially agile practices such as TDD with in depth knowledge of Object Oriented Programming, SOLID Principles, Gang of Four Design Patterns, Some Enterprise Application Architectural Patterns. Over 8 years of software development experience ASP.NET. Has the ability to understand and transform complex business requirements into software ensuring applications are delivered on time. Also experience in non Microsoft .NET technologies such as Dapper.Net, Git, Structure Map & Angular, Bootstrap, HTML-5, CSS-3 etc.

Category: Agile Software Engineering Tags: , , , , , ,
Md. Mojammel Haque

About Md. Mojammel Haque

CSM, CSPO, CSD, CSP-SM, CSP-PO (ScrumAlliance.org) Certification Profile Link- https://www.scrumalliance.org/community/profile/mhaque13 Currently working as Lead Team (Application Architecture) at Raven Systems Ltd. Passion for software development especially agile practices such as TDD with in depth knowledge of Object Oriented Programming, SOLID Principles, Gang of Four Design Patterns, Some Enterprise Application Architectural Patterns. Over 8 years of software development experience ASP.NET. Has the ability to understand and transform complex business requirements into software ensuring applications are delivered on time. Also experience in non Microsoft .NET technologies such as Dapper.Net, Git, Structure Map & Angular, Bootstrap, HTML-5, CSS-3 etc.

Leave a Reply

Your email address will not be published. Required fields are marked *