Event Driven Programming (CoSc4062)

• Chapter 1 outlines:
1. Introduction to Software Development
2. Software Development Approaches
3. Rapid Application Development
4. Software Development Principles

1
1. Introduction to Software Development
• Software development is a complicated process.
• It requires careful planning and execution to
meet the goals.
• Sometimes a developer must react quickly and
aggressively to meet every changing market
demands.
• Maintaining software quality hinders fast-paced
software development, as many testing cycles are
necessary to ensure quality products.
2
 1. Introduction to Software Development, … cont’

 Each software development project has to go

through at least the following stages:
 Requirement gathering;
 Writing functional specifications;
 Creating architecture and design documents;
 Implementation and coding;
 Testing and quality assurance;
 Software release;
 Documentation;
 Support and new features.
3
… Components of a Development System:
 Depending upon the requirements of a project,
different types of components can be chosen.
 Typically each development platform consists of the
following components:
 Hardware platform
 Operating system
 Editors
 Compilers and assemblers
 Debuggers
 Version control system
 Collaboration and bug tracking
4
2. Software Development Approaches
• A software development approach is a way to improve
design and product management by breaking software
development work into smaller steps or sub-processes.
• The Software Development Process is the structured
approach to developing software for a system or
project, sometimes called the Software Development
Life Cycle (SDLC).
• Several approaches can be used, including waterfall,
spiral, Agile, and incremental development.
• These different approaches will focus the testing effort
at different points in the development process.
5
2. Software Development Approaches, … cont’
• There are four main types of software development
approaches which are:
• Waterfall Approach
• Incremental Approach
• Spiral Approach
• Agile (Scrum)
• Waterfall approach: - activities are performed in order,
with possibly minor overlap, but with little or no iteration
between activities.
– The waterfall model is often also referred to as the
linear and sequential model.
– In this model, the software development activities
move to the next phase only after the activities in the
current phase are over.
6
2. Software Development Approaches, … cont’

7
2. Software Development Approaches, … cont’
• Incremental Approach: - determines user needs and
defines the overall architecture, but then delivers
the system in a series of increments (“software builds”). -
- The first build incorporates a part of the total planned
capabilities, the next build adds more capabilities, and so
on, until the entire system is complete.

8
2. Software Development Approaches, … cont’
• Spiral Approach: - a risk-driven controlled prototyping
approach that develops prototypes early in the
development process to address a risk.
- It specifically address risk areas followed by an
assessment of prototyping results and further
determination of risk areas to prototype.
- Areas that are prototyped frequently include user
requirements and algorithm performance.
- Prototyping continues until high-risk areas are resolved
and mitigated to an acceptable level.
- During each iteration or loop, the system is explored at
greater depth, and more detail is added .
9
Fig. Spiral approach

10
2. Software Development Approaches, … cont’
• Agile (Scrum): - The Agile software development process
and its most popular method, Scrum, use a dynamic and
iterative way to build software.
- Teams in Agile work in “Sprints” of a week or a few
months to build and release software that customers
can use and give feedback on.
- Agile is all about moving quickly, putting out new
versions often, and responding to what your users really
need, even if that goes against what you had planned.
- This means you don’t need a full list of requirements
and a full SOW before starting work.
- Instead, you move in one direction with the idea that
you will change directions along the way.
11
 3. Rapid Application Development
• Rapid Application Development or RAD means an
adaptive software development model based on
prototyping and quick feedback with less emphasis on
specific planning.
• It’s a continuous evolution of development philosophies.
• In general, the RAD approach prioritizes development and
building a prototype, rather than planning.
• Developers can quickly make multiple iterations and
updates to the software without starting from scratch.
• This helps ensure that the final outcome is more quality-
focused and aligns with the end users’ requirements.
12
 3. Rapid Application Development, … cont’
• When compared to other software development models,
the RAD framework varies by a considerable amount.
• Obviously, the major difference is how rapid application
development focuses on speed when comparing with
other models which usually focus on bringing a working
product to the customer.
• Rapid application development is particularly useful for
small businesses that need software done quickly, whilst
having a lot of input during the development process.
• Centric Consulting - a developer familiar with RAD and
agile development methodologies, had a client come to
them with a requirement for software that would
interface with their customers. 13
 4. Software Development Principles
 Software development principles are a set of
specific rules and guidelines.
 You need to follow certain principles when writing
code if you want to write clean, understandable,
and easily maintainable code.
 That is, there is no magic wand that can turn a
mixture of variables, classes, and methods into a
perfect code; but
 there are some hints that help the programmer
determine if he is doing everything right.
14
4. Software Development Principles, … cont’
• Let’s take a look at these basic guidelines:
KISS, DRY, YAGNI, BDUF and SOLID
• These are a set of software development principles that
any developer should know and should be refreshed from
time to time. Let's see few:
• KISS: Keep It Simple, Short. The main idea is to keep the
code as simple as possible so that it is easier to work with
later.
• Complex or complicated code takes longer to design, write,
and test and might be harder to modify or maintain in the
future.
• However, still avoid being “cheap” at the design stage.
• Simplicity is much better, but missing the essential
requirements and not including them in the process is just
as bad as overcomplicating it.
15
4. Software Development Principles, … cont’
• DRY (Don’t Repeat Yourself) is a principle of software
development aimed at:
– reducing repetition of code, replacing it with
abstractions or using data normalization to avoid
redundancy.
• Sometimes in Go you need to write a copy of a function
if you need additional parameters.
• In Go, the lack of function overloading and default values
for arguments requires writing a new function and
setting a default value and calling the same function.
• Go has packages that allow us to focus on code with DRY
principle.
16
 4. Software Development Principles, … cont’
• YAGNI (You Aren’t Gonna Need It) is simple and obvious
principle, but not everyone follows it.
• If you write code, then be sure that you will need it, as
described in the requirements.
• BDUF (Big Design Up Front): this software engineering
principle affirms that a developer should complete the
project’s design first.
• After that, they can now implement it.
• Proponents reason that this helps discover issues at the
requirements stage and solve them quickly.
• At every step, implement the BDUF principle before the
actual coding process.
17
4. Software Development Principles, … cont’
• SOLID: The SOLID principles are essentially a set of rules for
helping you write clean and maintainable code, and the most
well-known principle of software development.
• S – the principle of single responsibility.
– Go doesn’t have classes, but if we replace the word class
with objects (structs, functions, interfaces or packages)
must have only one responsibility, a single important
unifying idea, functions that serve a single purpose.
• O – Objects must be open for extension but closed for
modification.
– It’s about not overriding methods or classes, just adding
extra functionality as needed.
– A good way to solve this problem is to use inheritance.
18
4. Software Development Principles, … cont’
• L – The Liskov Substitution Principle states that:
– a derived class should be substitutable for its base class.
– In other words, if a program is using a base class, it should
be able to use a derived class without knowing it.
• I – Interface Segregation Principle –Clients should not
be forced to depend on methods they do not use.
• D – Dependency Inversion Principle:
– High-level modules should not depend on low-level
modules, but both should depend on abstractions.
– Abstractions should not depend on details.
– Details should depend on abstractions.
19
End chapter 1!

20