SDA ASSSIGNMENT NO 4

SUBMITTED BY: Mohsin Aslam

SECTION: BCSE 6B
REGISTRATION NO: F171BCSE186
Q.1 Explain the system’s decomposition stages into
subsystems

System Decomposition
System decomposition begins by decomposing the system into cohesive, well-defined
subsystems. Subsystems are then decomposed into cohesive, well-defined
components. Components are then decomposed into cohesive, well-defined sub-
components:
In fact, there is no important distinction between system, sub-system, component, and
sub-component. So the above process can be reduced to a simpler iterative process:

 
Q.2 Name and explain the eight design issues in software
design.
A number of key issues must be dealt with when designing software. Some are quality
concerns that all software must address—for example, performance, security, reliability,
usability, etc. Another important issue is how to decompose, organize, and package
software components. This is so fundamental that all design approaches address it in
one
way or another Software Design Principles, Software Design Strategies and Methods).
In
contrast, other issues “deal with some aspect of software’s behavior that is not in the
application domain, but which addresses some of the supporting domains”. Such
issues,
which often crosscut the system’s functionality, have been referred to as aspects, which
“tend not to be units of software’s functional decomposition, but rather to be properties
that affect the performance or semantics of the components in systemic ways”. A
number
of these key, crosscutting issues are discussed in the following sections (presented in
alphabetical order).
2.1 Concurrency
Design for concurrency is concerned with decomposing software into processes, tasks, and
threads and dealing with related issues of efficiency, atomicity, synchronization, and scheduling.
2.2 Control and Handling of Events
This design issue is concerned with how to organize data and control flow as well as how to
handle reactive and temporal events through various mechanisms such as implicit invocation
and call-backs.
2.3 Data Persistence
This design issue is concerned with how to handle long-lived data.
2.4 Distribution of Components
This design issue is concerned with how to distribute the software across the hardware
(including computer hardware and network hardware), how the components communicate, and
how middleware can be used to deal with heterogeneous software.
2.5 Error and Exception Handling and Fault Tolerance
This design issue is concerned with how to prevent, tolerate, and process errors and deal with
exceptional conditions.
2.6 Interaction and Presentation
This design issue is concerned with how to structure and organize interactions with users as
well as the presentation of information (for example, separation of presentation and business
logic using the Model-View-Controller approach). Note that this topic does not specify user
interface details, which is the task of user interface design (see topic 4, User Interface Design).
2.7 Security
Design for security is concerned with how to prevent unauthorized disclosure, creation,
change, deletion, or denial of access to information and other resources. It is also
concerned with how to tolerate security-related attacks or violations by limiting damage,
continuing service, speeding repair and recovery, and failing and recovering securely.
Access control is a fundamental concept of security, and one should also ensure the
proper use of cryptology.

Q.3 Explain the system issues and their relationship with the
system design

A process as complex as product software development comes with its

own set of challenges – challenges that you might encounter every day;
challenges that need to be addressed almost immediately to reduce the
impact they have on your end product.

So, we’ve identified the biggest challenges for software product companies,

but what can you do to overcome them?

Challenge 1: Project Infrastructure

Problem: An unestablished project environment is always a common
challenge in terms of its impact on project delivery. If the environment is not
available, then there is no way you can proceed with your project on time
and under budget.

Solution: To ensure efficient project development, test and pre-production

environments should be made available during the development, testing,
and user acceptance testing (UAT) phases. Invest in a solid IT
infrastructure upfront to create a better software development environment.

Challenge 2: Development Expectations and Outcome

Problem: A major reason for the complexity of software projects is the
constant changing of requirements. Not surprisingly, 33% of the
respondents of the Stack Overflow Developer Survey consider building
products with unspecific requirements, as their biggest
challenge. Requirements gathering is a lot more than a handful of business
consultants coming up with their ideal product – it is understanding fully
what a project will deliver.

Solution: To ensure that the product outcomes align with expectations and
requirements, a solid process and line of communication need to be
established. Remember the following best practices.

 Define and agree on the scope of the project

 Don’t assume end-user needs and requirements
 Communicate the needs and expectations between the development and ideation teams
 Involve users from the start of existing product refurbishment
 Consider UX from the start of new product development
 Create a clear, concise and thorough requirements document and confirm your
understanding of the requirements
 Create a prototype to confirm and/or refine final agreed-upon requirements

Challenge 3: Quality Assurance

Problem: Not reviewing code, or suppressing errors are just a means that
developers use to save time and meet deadlines.

Solution: Following a formal quality assurance process is imperative for a

successful launch. If you witness developers trying to cut corners in the
development process, discourage it immediately. Encourage them to
use best code development practices to meet the requirements sooner and
more efficiently

Challenge 4: Undefined Quality Standards

Problem: Defect identification is inevitable during functionality testing, even

if the product has been through thorough unit testing during the
development phase.

Solution: When you come out with the test approach, scenarios,

conditions, cases, and scripts, make sure your test plan covers all the
requirements that are to be delivered by planning several cycles of testing.

Challenge 5: Adapting the Latest Market Trends

Problem: Catering to the latest technology requirements such as mobile-
first or mobile-only or desktop-first is often challenging. If you don’t have
resources with hands-on experience in the latest and trending
technologies, it is sure to impact your time to market.

Solution: Make sure your resources constantly polish their skills to remain

relevant. This means staying up-to-date on market trends and
exploring insights into the new technology and trends that are out there.

Challenge 6: Design Influences

Problem: Product designs are under constant influence from stakeholders,
the development organization, and other internal and external factors.
Managing these influences is essential for maximizing the quality of
systems and their related influence on future business opportunities. The
increase of easily accessible, simple applications has resulted in user
expectations growing exponentially.

Solution: Make sure you streamline your design and offer a consistent

experience across devices, operating systems, and form factors.

Challenge 7: System & Application Integration

Problem: There are thousands of different technologies, systems, and
applications available for businesses. Integrating third-party or other
custom applications, such as your ERP systems, website, or inventory
management database adds substantial complexity to your project. And the
bigger challenge with integration is that they remain hidden throughout the
development process, and surface only at the end, leading to extra costs,
delays, lowered quality, and sometimes even failure of the project.

Solution: To conform your software solution to the external constraints of

other systems, you should:

 Get a clear understanding of end-user requirements

 Implement an enterprise-wide framework for the platform structure of the application
 Discover and research new technologies
 Design and develop new solutions
 Test and evaluate ideas to ensure optimum integration
 Pay extra attention to research and development, testing, and prototyping.
 Test, test, and test again before deploying the solution
Challenge 8: Project Management
Problem: Very often multi-tasking might give you more trouble than
expected. Resources cannot focus on a single task or module if their
manager bombards them with tasks.

“To be successful in project management you absolutely have to be an

excellent planner,” says Ryan Chan, founder and CEO of UpKeep
Maintenance Management.

Solution: One obvious way to be an excellent planner is to leverage

project management tools like Project Pro in O365 and keep projects,
resources, and teams organized and on track. Stay on track, meet all
deadlines, work seamlessly across applications, and efficiently and
effortlessly manage your projects. Always keep task allocation sequential
rather than parallel and encourage resources to give their best in whatever
they do.

Challenge 9: Test Environment Duplication

Problem: Testing a software system in a controlled environment is difficult
since the user is not immersed in a completely realistic working situation.
It’s impractical to gauge how a user will really use the application in
different situations on a regular basis until it’s deployed. However, with
software applications for both B2B and B2C segments becoming more and
more diversified than in the past, controlled testing is not sufficient.

Solution: Testing the software, application or product in a separate real-life

test environment is critical to your software’s success. This will allow you to
see what is working well and what is working poorly in a vacuum vs real-life
use.

Challenge 10: Security Infrastructure

Problem: Security breaches are on the rise; a recent study estimates that
96% of all web applications contain at least one serious vulnerability. How
do you cope with evolving security threats? How do you keep each layer of
your software or application secure?

Solution: Security is not just the responsibility of the software engineer but

also the responsibility of all the stakeholders involved including the
management, project managers, business analysts, quality assurance
managers, technical architects, and application and developers. If you want
to keep your infrastructure and company safe, remember the following best
practices:

 Look beyond technology to improve the security of your software

 Develop software using high-level programming languages with built-in security features
 Require security assurance activities such as penetration testing and code review
 Perform essential core activities to produce secure applications and systems

Q.4 Illustrate the client, end user, developer relationship as

stakeholders in a software design process .

End User: End user basically the user which will use your
application to get benefit from it and in return become a source of
income to you.
Developer : Developer are the people which will maintain your
product and will check timely that is anything required or need to
do changes in your system to make it better and user friendly for
the clients.

Q.5. What are the six general trade-off issues in a software design
process?

Conceptual design involves a series of tradeoff decisions among significant

parameters - such as operating speeds, memory size, power, and I/O
bandwidth - to obtain a compromise design which best meets the
performance requirements. Both the uncertainty in these requirements and
the important tradeoff factors should be ascertained. Those factors which
can be used to evaluate the design tradeoffs (usually on a qualitative basis)
include:

 Reliability
 Expandability
 Programmability
 Maintainability
  Compatibility
 Adaptability
 Availability
 Development Status and Cost

Q.6 Map a network packet communication example in terms

of software-modular based communication.
Network mapping is the study of the physical connectivity of networks e.g. the Internet.
Network mapping discovers the devices on the network and their connectivity. It is not to be
confused with network discovery or network enumerating which discovers devices on the
network and their characteristics such as (operating system, open ports, listening network
services, etc.). The field of automated network mapping has taken on greater importance as
networks become more dynamic and complex in nature.

Q.7 Explain the following terms in details

Sub-routine: Subroutines may be defined within a program, or a set of
subroutines may be packaged together in a library. Libraries of subroutines
may be used by multiple programs, and most languages provide some
built-in library functions. The C language has a very large set of functions in
the C standard library. All of the functions in the C standard library are
available to any program that has been linked with the C standard library.
Even assembly programs can make use of this library. Linking is done
automatically when is used to assemble the program source. All that the
programmer needs to know is the name of the function and how to pass
parameters
Co-routines: Coroutine basically is general control structures where flow
control is cooperatively passed between two different routines while
returning. They are computer program components that generalize
subroutines for non-preemptive multitasking, by allowing execution to be
suspended and resumed.

Coroutines are well-suited for implementing familiar program components

such as cooperative tasks, exceptions, event loops, iterators, and infinite
lists. To know the in-depth definition, click here.

Why Coroutines is Required

In order to read a file and parse it while reading into some meaningful data,
one can either read it step by step at every line or may also load the entire
content in memory, which would not be recommended for large text cases
e.g text editors like Microsoft Word. In general, to throw away the stack
concept completely, it is needed. And also when we want things to do
concurrently i.e. non-preemptive multitasking, we need coroutines for
concurrency.
 How Coroutines Works

It rescheduled at specific points in the program and do not execute

concurrently, programs using coroutines can avoid locking entirely.
This is also considered as a benefit of event-driven or asynchronous
programming.

It is almost similar to threads but one main difference is that threads are
typically preemptively scheduled while coroutines are not and this is
because threads can be rescheduled at any instant and can execute
concurrently while coroutines rescheduled at specific points and not
execute concurrently.

Use Cases of Coroutines

o State Machines
o Actor Model
o Generators
o Communicating Sequential Processes
o Reverse Communication

State Machines: It is useful to implement state machines within a single

subroutine, where the state is determined by the current entry or exit point
of the procedure. This results in the more readable code as compared to
the use of goto.

Actor Model: It is very useful to implement the actor model of concurrency.

Each actor has its own procedures, but they give up control to the central
scheduler, which executes them sequentially.

Generators: It is useful to implement generators which are useful for

streams particularly input/output and for traversal of data structures.

Communicating Sequential Processes: It is useful to implement

communicating sequential processes where each sub-process is a
coroutine. Channel input/output and blocking operation yield coroutines and
a scheduler unblock them on completion events.
Reverse Communication: They are useful to implement reverse
communication which is commonly used in mathematical software, wherein
a procedure needs the using process to make a computation.

Comparison with Subroutines and Threads

Subroutines are the special cases of coroutines. When subroutines are

called, execution begins at the start, and once subroutines exit, it is
finished. An instance of a subroutine only returns once, and it does not hold
state between invocations.

This is very much similar to threads. However, coroutines are cooperatively

multitasked while threads are preemptively multitasked. This means that
coroutines provide concurrency, not parallelism.

Benefits of Coroutines

1. Implement in asynchronous programming.

2. Implement functional programming techniques.
3. Implement it because of poor support for true parallelism.
4. Pre-emptive scheduling can be achieved using coroutines.
5. Keep the system’s utilization high.
6. Requires less resource than threads.
7. Resource locking is less necessary.
8. Increases locality of reference.

1. Event-based style: What is event-based architecture? Event-based

architecture is an architectural design that uses the production and consumption of events to
control behaviour. When a specific component has finished running, instead of directly calling
a function of another component to incite additional actions, it would instead produce and
propagate an event out via an event bus to other components, which will then react by
performing some actions.