You are on page 1of 17

Unit 6 Software Design

and Development

ALL OF THE TASKS


(P5) TASK 1.1- EXPLAIN THE ROLE OF SOFTWARE DESIGN PRINICIPLES
AND SOFTWARE STRUCTURES IN THE IT SYSTEMS DEVELOPMENT LIFE
CYCLE
(M1) TASK 1.2- EXPLAIN THE IMPORTANCE OF THE QUALITY OF CODE
(D1) TASK 1.3- DISCUSS THE FACTORS THAT CAN IMPROVE THE
READABILITY OF CODE

Pelal Mohammed BMC151635341


BIRMINGHAM METROPOLITAN COLLEGE | [COMPANY ADDRESS]
Contents
Task 1.1- explain the role of software design priniciples and software structures in the IT systems
Development Life Cycle .......................................................................................................................... 3
Introduction ............................................................................................................................................ 3
Feasibility Study .................................................................................................................................. 3
Technical Feasibility ........................................................................................................................ 3
Economic Feasibility ........................................................................................................................ 3
Operational Feasibility .................................................................................................................... 4
Legal Feasibility ............................................................................................................................... 4
Schedule Feasibility ......................................................................................................................... 4
Requirements gathering and Specification ......................................................................................... 4
Design.................................................................................................................................................. 4
Code .................................................................................................................................................... 4
Test...................................................................................................................................................... 5
Maintain .............................................................................................................................................. 5
Global, plus local variables......................................................................................................... 5
Local Variable ...................................................................................................................................... 5
Global Variable .................................................................................................................................... 5
Comparison between local and global variables ................................................................................ 6
Functions ............................................................................................................................................. 7
Procedures....................................................................................................................................... 7
Classes and objects ...................................................................................................................... 7
Predefined Code ........................................................................................................................... 8
Conclusion ............................................................................................................................................... 9
Task 1.2- Explain the importance of the quality of code ...................................................................... 10
Introduction .......................................................................................................................................... 10
The Significance of good quality code ............................................................................................. 10
Efficiency ........................................................................................................................................... 10
Maintainability .................................................................................................................................. 10
Portability.......................................................................................................................................... 10
Reliability & Robustness.................................................................................................................... 10
Usability ............................................................................................................................................ 11
Reusability ......................................................................................................................................... 11
Conclusion ............................................................................................................................................. 11
Task 1.3- Discuss the factors that can improve the readability of code............................................... 12
Introduction .......................................................................................................................................... 12
Comments ......................................................................................................................................... 12
Indentation ....................................................................................................................................... 13
Modular Structure ............................................................................................................................ 14
Naming Conventions ......................................................................................................................... 14
Syntax Highlighting ........................................................................................................................... 14
Conclusion ............................................................................................................................................. 15
Bibliography.......................................................................................................................................... 15
Task 1.1- explain the role of software design priniciples
and software structures in the IT systems Development
Life Cycle
Introduction
In this report I will be explaining the role of software design principles and software structures in the
IT systems development life cycle, it’s split into two sections one which is software design principles
talking about the feasibilities such as technical, economic, operational, legal and schedule. Then we
talk about the stages taking place when design a software which are requirement, design, code, test
and maintain. Furthermore in the software structure within it I will talk about the global and local,
functions, procedure, class and objects and lastly predefined code.

Software design principles


Feasibility Study
Feasibility study is characterised as the reasonable degree to which a project can be performed
effectively. To assess attainability, a plausibility examine is performed, which decides if the
arrangement considered to achieve the prerequisites is handy and workable in the product. Data, for
example, asset accessibility, cost estimation for programming advancement, advantages of the
product to the association after it is created and cost to be brought about on its upkeep are
considered amid the achievability contemplate. The goal of the practicality think about is to build up
the explanations behind building up the product that is worthy to clients, versatile to change and
similar to build up principles. Different objectives of feasibility study are to analyse whether the
software will meet organisational requirements, decide if the software can be executed utilising the
present technology and inside the predefined spending budget and schedule and to decide if the
software can be incorporated with other existing software.

Technical Feasibility
During this studying, the analyst distinguishes the current PC systems (equipment and programming)
of the concerned office and decides if these specialised assets are adequate for the proposed system
or not. On the off chance that they are not adequate, the expert recommends the design of the PC
systems that are required. The expert by and large seeks after a few unique designs which fulfil the
key specialised necessities yet which speak to various expenses. Amid specialised achievability
examine, money related assets and spending plan is likewise considered. The fundamental goal of
specialised possibility is to decide if the undertaking is in fact doable, if it is monetarily practical.

Economic Feasibility
Economic feasibility is the most imperative investigation that decides the cost and advantages of the
proposed system and contrasts and the financial plan. The cost of the project ought not to exceed
the financial plan. The cost of the undertaking incorporates the cost of equipment, programming,
improvement and usage. Cost/advantage investigation is the regular strategy to decide the
advantages that are normal from the proposed system and contrast them with the costs expected
with spend on advancement of the system. In the event that advantages are observed to be more
than costs, at that point the examiner chooses to proceed with the advancement of the proposed
system generally thinks of it as financially not doable. The achievability think about presents both
unmistakable (e.g., expanded efficiency, low working cost, and so forth.) and impalpable advantages
(e.g., enhanced authoritative arranging, enhanced resource use, and so on.) formally. We will
examine the cost/advantage examination in an ensuing sub-area.

Operational Feasibility
When it is discovered that the project is both monetary and specialised doable, the following stage is
to decide if it is operationally plausible or not. Amid operational achievability consider, it is resolved
whether the system will work in the way that client needs. Operational feasibility relies on HR for the
advancement and execution of the system. It is considered whether the qualified and experienced
labour is accessible for improvement and execution of the system. Client association is more
required in deciding the operational feasibility.

Legal Feasibility
Legal feasibility is an assurance of whether a proposed project encroaches on known Acts, Statutes,
and in addition any pending enactment. In spite of the fact that in a few examples the project may
seem sound, on nearer examination it might be found to encroach on a few lawful territories.

Schedule Feasibility
Schedule feasibility is an assurance of whether a proposed undertaking can be actualised completely
inside a stipulated time allotment. In the event that an undertaking takes excessively time it is
probably going to be rejected.

Requirements gathering and Specification

Amid this period of the cycle, the customer will list what they will require from the product.
A ton of gatherings will be held between the customer, project supervisors and partners.
This stage is the principle center for the undertaking directors. Amid these gatherings, a
choice will be made on who the system is for and how the system will be utilised, inquiries
and concerns will likewise be replied amid this stage as most ideal. The necessities
portrayed by the customer will likewise be examinations for legitimacy, for instance, is the
prerequisite practical? Or then again is it conceivable? At the point when all gatherings are
held, a Requirement Specification record is made as a rule for the following stage which will
be the outline stage.

Design

The designer would then be able to utilise the documentation delivered by the past stage
keeping in mind the end goal to outline the application as indicated by necessities. A few
components of configuration may incorporate building up design – the route in which
information streams all through a system or how elements inside the product convey and
respond to each other. The engineer may likewise outline a few components of the front-
end of the application, for example, the interface and information techniques.

Code

Once an application has been outlined, an engineer is then able to do really programming
the product. On the off chance that an advancement group is comprised of various
developers, it might be astute to part up work coherently and separately. This stage
frequently sets aside the longest measure of opportunity to finish.
Test

It is vital to test an application with a specific end goal to guarantee that it meets the desires
of both a customer and client. Documentation that had been delivered beforehand may aid
this progression by demonstrating an analyser what usefulness is expected of a system.
Analysers may use an assortment of techniques to guarantee that their application is doing
scratch, including both practical and non-utilitarian testing.

Maintain

This stage will be continuous, when bugs are found in the system that were missed amid
testing or issues happen inside the product, these issues should be made plans to keep the
system attempting to the best of its capacity. This stage is simply dealing with the
improvement item.

Software structures
Global, plus local variables
Local Variable
A local variable is constantly announced inside a function piece. In C, a local variable is proclaimed
toward the begin of a code block. In C++, they can be proclaimed anyplace in the code obstruct
before their utilisation. Nearby factors can be gotten to just by the announcements composed inside
a function in which the local variables are proclaimed. They are secure it might be said that, they
can't be gotten to by some other function of a similar program.

Local variable exist till the piece of the function is in execution, and accordingly pulverised after the
execution leaves the block. Local variable lose their substance when the execution left the piece in
which they are proclaimed.

The purpose for it is that the local variables are put away on the stack unless their extraordinary
stockpiling is indicated. The stack is dynamic in nature, and the adjustment in memory area prompts
the motivation behind why local variable doesn't hold their incentive when the block of a function
exists.

Global Variable
A global variable is proclaimed outside every one of the functions show in a program. Dissimilar to
local variable, the global variable can be gotten to by any function show in a program. Global
variable are very little solid as their esteem can be changed by any capacity display in the program.

Global variable stay in presence till the entire program gets executed totally. Global variables hold
their qualities till the program is in execution. The reason is that they are put away on a settled
locale of memory, chose by the compiler.

A Global variable is useful in circumstances where numerous functions are getting to similar
information. Utilising a substantial number of global variables may be dangerous, as there might be
undesirable changes to the estimation of a global variable.
Comparison between local and global variables
Local Variables are called 'local' since they are just known to the announcements written in a
function inside which they are pronounced and not known to some other function display outside
that function square. On account of worldwide variable they are known to every single function
introduces in a program; henceforth, they are called 'global'.

Global variables hold their incentive till the program is in the execution stage, as they are put away
at a settled area chose by the compiler. Local variables are put away on the stack; subsequently,
they don't hold their incentive as 'stack' is dynamic in nature; however the compiler can be
coordinated to hold their esteem, by utilising the 'static' modifier.

In the event that a global and a local variables are announced with a similar name at that point,
every one of the statements of a code block in which local variable is pronounced will allude just to a
local variable and will make no impact a global variable.

A local variable is pulverised when the control of the program exit out of the square in which local
variable is proclaimed. Be that as it may, a global variable is demolished when the whole program is
ended.

BASIS FOR LOCAL VARIABLE GLOBAL VARIABLE

COMPARISON

Declaration Variables are declared Variables are declared

inside a function. outside any function.

Scope Within a function, inside Throughout the

which they are declared. program.

Access Accessed only by the Accessed by any

statements, inside a statement in the entire

function in which they program.

are declared.

Life Created when the Remain in existence for


function block is entered the entire time your

and destroyed upon program is executing.

exit.

Storage Local variables are Stored on a fixed

stored on the stack, location decided by a

unless specified. compiler.

Functions
All functions are types of procedures. The functions break the entire program into sub-steps which
makes it significantly less demanding to utilise. With utilising functions we can spare heaps of time
while we are customising as we don't need to compose similar codes over and over. The functions
are separated into two distinct parts.

Figure 2 here is an example of the function code

Built-in functions are kind of functions that are planned inside the program by the programmers
which are available by the client. Built-in functions cannot be changed by the client. User defined
functions are sort of functions which are composed by the client while programming. The user-
defined functions can be distinctive as they are composed by various programmers.

Procedures
Procedures make the program less demanding to comprehend as it isolates the program into little
pieces; in this way the codes are littler and easier. Now and then while you’re programming
(particularly in enormous tasks) you may wind up with long lines of codes which may look
exceptionally befuddling and entangled. This is on the grounds that in bunches of parts of your
programming you have to repeat a similar sort of code and again keeping in mind the end goal to
make your program. We can utilise methodology through our program to make it less demanding
and easier.

Classes and objects


This is when the code is separated in to chunks. This is when an object (in this shape known as class),
takes its properties from another. (Known as the parent, super or sub class). At the point when this
happens the derived class is known as the sub or determined class. These acquire the distinguishing
highlights, (for example, calculations) from the parent class.
In this example we see that the sub-class (beneath)
has inherited from the parent class in that it is
characterised as individual. This means that
consequently it has a name, a D.O.B (Date of Birth)
and a sexual orientation. This spares the developer
from having to re-compose the code to mirror this,
thus we see inheritance of these highlights. The
Form we see here is known as single inheritance.
This is the point at which the determined class is
inferred from only one parent class.

Predefined Code
What pre-defined code is in basic language, it’s when code has been pre-defined. In this case it can
be a key role of code which is definitely be needed in every place of the system or can be even
simply the majority of them and that will simply to save more time in the programming stages.

In Visual basic, the simplest way to include a dialog box into the user’s application by using a
predefined dialog as the programmer doesn’t have to worry about how to design, load or show the
dialog box. Though, controlling the appearance is limited for the user. Predefined dialog boxes are
always modal.

Figure 4 shows you some predefined codes in visual basic this is higher level of coding

This relates to the software development lifecycle because the pre-defined code has related code
that is contained and only accessible when and where needed. They also support the use of reusable
and pre-defined code that has the potential to be used on more than one project.
Conclusion
In conclusion I have explained the role of software design principles and software structures in the IT
systems development life cycle, explaining the feasibilities such as technical, economic, operational,
and legal and schedule. The stages taking place when design a software which are requirement,
design, code, and test and maintain and in the global and local, functions, procedure, class and
objects and lastly predefined code. In which I added images in that support my evidence.
Task 1.2- Explain the importance of the quality of code

Introduction
Within this report I will be explaining the importance of the quality of code, firstly I will talk about
the significance of good quality of code then the rest of the headings I will be covering are efficiency,
maintainability, portability, reliability & robustness, usability and reusability thoroughly explaining
the importance of the quality of code in detail.

The Significance of good quality code


Keeping in mind the end goal to grow great quality code, a developer must have a decent measure
of involvement in programming and they should be fit for conquering issues that accompany
programming. Making great quality code is vital fundamentally in light of the fact that it will then
outcome in the product being more strong and substantially simpler to utilise and can be kept up
without hardly lifting a finger. Great quality code will meet the client necessities and work how it
was embarked to do in the plan stages, for example, the program doesn't all of a sudden crash. The
readability of code will likewise make the code to a vastly improved quality. There are diverse
variables that can enhance the nature of code, for example, maintainability, robustness, reliability
and portability.

Efficiency
It is constantly great to ensure you keep your code is always efficient. Efficient of code covers an
assortment of things, for example, the reliability and speed being two example. Examples such as on
the best way to guarantee that your code is productive are to erase the irrelevant codes, make
utilisation of ideal memory, make utilisation of reusable segments at whatever point you can and
use the best data types, key words and variables. Efficiency of code isn't only about ensuring that
your code simply accomplishes something, yet that it accomplishes something extremely well.

Maintainability
Whenever a program is created, is should be viable. At whatever point somebody utilises a program,
it is conceivable that there could be bugs that weren't distinguished amid the testing phase of
improvement so it is imperative for these bugs to be settled. The program is likewise going to
require updating keeping in mind the end goal to enhance the program's usefulness. The
maintenance of the program is improved and less demanding if the program has things like remarks
and appropriate variable names. This enhances the readability of code which makes it significantly
simpler to distinguish mistakes and furthermore enhances the maintainability of the code

Portability
Portability as far as great quality code is the point at which we can code crosswise over various
systems and operating system(s). A program ought to be portable in light of the fact that if a
program was produced for a customer and it must be utilised on specific devices or Operating
system(s) then it would affect the way that the customer/organisation utilises the system. A decent
case of a programming language is Java since that can be utilised on any device which indicates it is
versatile. The following is a case of a program which isn't portable.

Reliability & Robustness


If a program is robust then it implies that it can deal with mistakes amid execution and furthermore
have the capacity to deal with contribution by the client which isn't right as indicated by the data
type that they have entered. For instance, if a program is requesting the first and last name of a man
and the client enter numbers for the principal name and letters for the second name, if the program
didn't acknowledge numbers as an info then it isn't robust. An illustration like this is appeared to one
side. At whatever point a program has been produced, it is conceivable that it might not have been
created in the right way. Clients may enter the off base data types which may prompt the program
not working since it is sitting tight for the correct data type to be enter and doesn't know how to
adapt to the wrong data type. Developers should have the capacity to make a more dependable and
strong program that can adapt to mistakes. A vigorous and dependable program can adapt to
blunders, for example, off base data types being contribution to the program so the programmers
could include a component in the program that shows a message to the client educating them that
they have entered the wrong data type.

Usability
The term sounds truly clear as crystal and that is on account of it is. At the point when a program is
more usable it concentrates on the client and how simple and viably the program can be utilised as a
part of specific ways. The following are two cases of projects where one exhibited preferable
convenience over the other. A program that has been created ought to be sufficiently simple for the
client to really have the capacity to utilise. The programmers can guarantee that a program is usable
by outlining and great interface for the program which can give the client a chance to associate with
the program. In the event that an interface required many controls, for example, textboxes and
buttons then it could be sorted out into gatherings, for example, the request of utilisation to make it
less demanding for the client.

Reusability
Reusability is the degree to which code can be utilised as a part of various applications with minimal
change. As code is reused in another application, that new application somewhat acquires the
qualities of that code. In the event that the code is maintainable, the application is more
maintainable. On the off chance that it is convenient, at that point the application is more portable.

Reusable code is produced from various perspectives. Code might be searched from a past project. A
reusable library of code might be produced starting with no outside help for an especially surely
knew space, for example, a math library. Reusable code might be created as a deliberate result of a
particular application. Reusable code might be created a specific way in light of the fact that an
outline technique requires it. These rules are proposed to apply in these circumstances.

Conclusion
In conclusion within this report I have explained the importance of the quality of code and talked
about the significance of good quality of code. I have also covered the efficiency, maintainability,
portability, reliability & robustness, usability and reusability plus I have thoroughly explained the
importance of the quality of code in detail. Now I have showed that I have completely finished of
M1.
Task 1.3- Discuss the factors that can improve the
readability of code
Introduction
For D1 in this report I will be discussing the factors that can improve the readability of code. What I
will be covering are the comment, indentation, modular structure, naming convention and syntax
highlighting, however not only will I be discuss it but I will also incorporate some images that will
support my evidence and it will also show my understanding of the factor that can improve the
readability of code.

Comments
A comment is an arrangement of characters that sit close by a line (or various) lines of code. Despite
the fact that these characters are inside a program and are intelligible by the developer, they are not
executed nor do they influence the arrangement in any capacity.

Comments are an extremely helpful tool that enormously enhances the readability of code by
enabling a programmer to include significant remarks or notes close by proclamations, clarifying
different usefulness and accordingly making the program more readable to either their self or
others. It is consequently exceptionally hard to comprehend the motivation behind the program and
what every announcement does, this program has awful readability.

An example of comments is shown below using Visual studio.

Programming languages have particular prefixes of which show that the accompanying characters
are remarks and ought not to be incorporated inside the program. For instance, C# utilises the
characters '//' to show a remark, while Python utilises the hash character. This prefix will generally
colour a comment a colour, for example, green, making it unmistakable against genuine code and in
this manner expanding the clarity of the code.

Indentation
Indentation by the tab key. This enables a programmer to isolate lumps of code by means of their
degree or operation. For instance, the procedures that happen inside a 'for' loop are typically
selected forward one to make it more detectable from other code.

Another line is normally utilised as a part of request to set apart statements and make them more
recognised from each other. Despite the fact that a programming language may offer the capacity
for a designer to not separate statement onto diverse lines, the procedure is generally prescribed
since it makes a program less demanding to troubleshoot, remark and read.

An example below shows what indented code normally looks like in Visual Studio.

The picture above demonstrates a bit of code that has not been indented at all. As should be
obvious, this example is genuinely hard to read and decode, along these lines making it mixed up. A
programmer could cure this issue by putting singular statement(s) on another line, including void
area between various segments of code, and indenting where suitable.

Some IDEs, for example, Visual Studio 2013 consequently modify the dividing and space in your code
to influence it to adjust to the standard, this demonstrates space and dispersing is critical to
numerous parts of readable code.
Modular Structure
The structure of a program characterises the route in which a designer has arranged different
districts of code and how the program streams according to a programmer. Regularly, factors are
characterised at the highest point of a program, function(s) in the centre and a principle work at the
base. Obviously, a programmer could rather arrange declaration in the middle of function(s);
however this may not really acquire great structure. Go to statement(s) are some of the time
considered awful practice since they clutter the stream of a program and thusly make it have an
awful structure. Code that is considered to have an awful structure is now and then named
'spaghetti code', since it is like spaghetti in the way that is a cluttered chaos and the procedures
inside the code are scattered and befuddling.

Naming Conventions
Inside programming, values are put away inside named variables. Despite the fact that it is
conceivable to name a variable about anything, you can enhance the readability of your code by
naming your factors pertinent and readable names. Despite the fact that the programmer may have
their own particular style of naming, a designer may utilise a standard style control keeping in mind
the end goal to make their code more coherent by other developer. A style manage is an
arrangement of models that give designers a progression of projects in the matter of how they
should name their factors. A case of a Python style manages is PEP 8.

A few cases of elements that play into the clarity of code by means of naming incorporate capital
letters, the partition of programming components (modules, functions, Booleans, and so on) and
separating inside variable names through underscores.

Syntax Highlighting
Numerous IDEs offer an element that enables key parts of code to be featured distinctive colours
relying upon their motivation. For instance, inside Visual C++, of course strings are coloured a pastel
orange, comments are coloured green and variable names are grey coloured. Despite the fact that
this can be changed inside the application, this is for the most part a decent and standard colour
plan for controlling code.
Examples of the different colouring in visual studio C++

Syntax highlighting enables a designer to rapidly tell the reason for specific statements inside their
code, in this way making it more comprehensible and enabling a programmer to comprehend and
change it effortlessly.

Conclusion
Throughout the whole report the following we have been through that are discussed the factors that
can improve the readability of code. We have covered and talked about the comment, indentation,
modular structure, naming convention and syntax highlighting, however in this report there are
some images that will support my evidence and this shows my understanding of the factor that can
improve the readability of code. Not only do good programmers/ developers need to know the
importance of readability but they also need to know how you can further improve it, if you always
keep in mind all the factors then the faster your write code with a low rate of bugs are present in all
of your code. Programmers should be writing readable code not just for machines to understand;
write it for us the humans so the code is more readable code , easier to improve it and also simpler
to located each of it and with all of this you can improve your coding skills to a better
understandable level.

Bibliography
Dinesh Thakur. 2018. What is Feasibility Study? Types of Feasibility. Explain Feasibility
Study Process. [ONLINE] Available at: http://ecomputernotes.com/software-
engineering/feasibilitystudy. [Accessed 24 January 2018].
MBA Knowledge Base. 2018. Feasibility Analysis in System Development Process.
[ONLINE] Available at: https://www.mbaknol.com/management-information-
systems/feasibility-analysis-in-system-development-process/. [Accessed 24 January 2018].
clashroyale. 2018. IMPORTANCE OF GOOD QUALITY CODE | clashroyale. [ONLINE]
Available at: https://crashroyale.wordpress.com/importance-of-good-quality-code/.
[Accessed 24 January 2018].
Callum's IT Blog. 2018. Assignment 2 | Callum's IT Blog. [ONLINE] Available at:
https://cavanzyl.wordpress.com/category/unit-6-11-16-programming-project/assignment-2/.
[Accessed 24 January 2018].
Callum's IT Blog. 2018. The Software Development Life Cycle | Callum's IT Blog. [ONLINE]
Available at: https://cavanzyl.wordpress.com/2016/03/24/the-software-development-life-
cycle/. [Accessed 24 January 2018].
jessicabass89. 2018. Software Development Life-Cycle – jessicabass89. [ONLINE] Available
at: https://jessicabass89.wordpress.com/2016/02/17/software-development-life-cycle/.
[Accessed 24 January 2018].
prezi.com. 2018. P5: Explain the role of software design principles and software by Amir
Ramezanzadeh on Prezi. [ONLINE] Available at: https://prezi.com/dnphscb-0_xq/p5-explain-
the-role-of-software-design-principles-and-softw/. [Accessed 24 January 2018].
Scribd. 2018. Assignment 2 - Software Development Life Cycle | Software Development
Process | Inheritance (Object Oriented Programming). [ONLINE] Available at:
https://www.scribd.com/document/82277405/Assignment-2-Software-Development-Life-
Cycle. [Accessed 24 January 2018].
Callum's IT Blog. 2018. Factors that can improve the Readability of Code | Callum's IT Blog.
[ONLINE] Available at: https://cavanzyl.wordpress.com/2016/05/02/174/. [Accessed 24
January 2018].
Reusability - Chapter 8 - Ada 95 QUALITY AND STYLE Guide . 2018. Reusability - Chapter
8 - Ada 95 QUALITY AND STYLE Guide . [ONLINE] Available at:
http://www.adaic.org/resources/add_content/docs/95style/html/sec_8/. [Accessed 24
January 2018].
Tech Differences. 2018. Difference Between Local and Global Variable (with Comparison
Chart) - Tech Differences. [ONLINE] Available at: https://techdifferences.com/difference-
between-local-and-global-variable.html. [Accessed 24 January 2018].