What is software engineering?
science of building large software systems → on time, within budget, with correct functionality, and good performance
we depend on software for our daily activities.
involves a broad range
of skills in computer science, in management, and in mathematics.
A software engineer should be expert in algorithmics and their complexity. A software engineer should be a good manager
because software is typically late and over budget. should know
several management techniques for planning
and scheduling each phase
of the software
Domain/main areas of software engineering
development
management
maintenance
What do we mean by large software systems?
A large software system means it has a large number of functions,
classes, and lines of code.
It involves a large team of
developers, which means programming. In the large, it is very expensive to develop. The lifetime of the software is measured
in terms of years to live long, and to undergo many versions during its lifetime.
what is the software system?
A software system has two parts, the hardware part and the software part.
We are building a software control, the hardware part. software costs dominate
the hardware costs in
software costs are increasing. The hardware costs are decreasing.
Characteristic of software engineering
there is a great commercial pressure to produce high quality software systems.
Indeed, a software engineer should be
able to implement several software quality (performance, portability,
robustness, security, scalability, user-friendly, fault-tolerance)
For example, if you
want to develop a baking system, the banking system should achieve several qualities. it should be secure, it should be scalable, it should be fast, it
should be user friendly, and so on. Scalable here means that the banking system should be able
to handle a large number
of concurrent user access.
A software engineer should be able to develop the software on time and within budget. Timeliness and productivity are still.
Challenging qualities to achieve.
A software engineer should be able to fix errors after
deploying the software
on the customer environment.
He should also be
able to maintain and improve the functionality of the software system and
provide an effective support for the end users.
History of software engineering
(Software crisis)
faced a crisis due to five factors.
- The problem requirement
were not well understood and unclear, we end up solving the wrong problem.
- Informal approaches,
which are based on natural languages, were used to
describe the problem requirements, which led to inconsistencies and ambiguities, especially when we are dealing with complex requirements.
- Software qualities were difficult to implement and still challenging today.
- Software became expensive to build due to their complexity and large size. Developers were faced with time pressure due to
the competition in the market.
- Developers faced problems of comm. and collaboration problem within their teams.
solution to software crisis
In 1968, developers met
at the network conference
to discuss the software crisis. First, they identified the main problems
as seen in the previous slide, and then proposed a solution to the software crisis.
The solution is to follow
an engineering approach
to build the software.
They named the solution Software Engineering.
In the conference, they also provided the first definition
of software engineering field. “Software engineering is the establishment and use of sound engineering principles in order to obtain economically software that is reliable and works efficiently on real machines.”
This definition means we need to define engineering principles and use them when developing a software.
Build a software using engineering approach.
In order to build
a software with a low cost and the obtained software is reliable and efficient to build the software, follow an engineering approach
in other engineering fields?
We also follow an engineering approach to develop a software based on well defined design methodologies, design principles, tools, management techniques, and team organization.
The only difference between software engineering and other engineering field is that the product is logical, not physical. Later on, the computing organization, I, triple E defined software engineering as follows. The application of a systematic, disciplined, quantifiable approach to the development, operation, and maintenance of software, That is, the application of engineering to software. Second, software engineering is the study of approaches as in one.
summary of the software engineering field. In software engineering, we are building as product,
which is called the software. We follow a process, which means an engineering approach.
To build that product,
we use tools to support the process, tools to assist and automate the development activities. These tools are called Tools in Software Engineering.
what is a software
Software is not only the code, but it also includes
the requirement specification document,
the design specification document, the cases,
the user documentation and the technical documentation also programs, test cases plus user documents.
two types of software: generic products that are developed for general market. (games, database management system,
word processor, project management tool, compiler , E mail system, a web browser.
Bespoke: We have customized
software that are developed
for specific customer in
order to solve a specific problem.
Role of software engineers
- be expert in programming
- should be able to translate vague requirement of the customer into a precise specification.
- He should know several design methodologies.
- He should be a good software architect. ( three layer architecture.)
- He should process good communication skills
to resolve conflict and misunderstanding among the stakeholders who come with different background in education. - He should be able to precisely plan, schedule, and coordinate the work.
Why do we still need software engineering
bc software systems
are becoming more complex. Examples of complex systems:
involves hetegogeneous devices that are difficult to interconnect. concurrent systems, where processes are performed in parallel.
Distributed systems where processes are deployed on multiple machines.
And real time systems where the response from the system should be fast.
Software engineering is needed to maintain existing software systems.
Example of software maintenance are fixing errors, improving existing features, like improving software qualities. Adding new features, like adding new functional requirements, adapting to new environments.
Maintaining software is
difficult because changing
one component may affect
all the components of the system. Software engineering is necessary to
develop critical software systems where errors can have catastrophic results
on the human lives and the environment. One subset of critical systems are called safety critical systems, such as aircrafts,
medical devices, nuclear stations. The system can have an impact directly on the human lives.
Software engineering is important for building software systems on time and within budget.
Because software is still
developed late and over budget. Due to their large size and complexity, we still need software engineering to incorporate the software engineering qualities such as maintainability, time efficiency, security,
productivity, scalability,
which are challenging, as
seen in the previous slide.
We need software engineering because we are still in crisis as the software is often delivered late.
why is software still late?
Software is late because of several management issues. For example, changing requirements are not reflected in the schedule, even though changing requirement is a very well known risk in software management and the estimation of technical difficulties. Because the problem is difficult
to solve unrealistic deadlines, lack of communication among
members of the project.
Lastly, fail to see that the project falls behind the schedule
Software life cycle
It’s a phased approach that we follow to build a high quality software. The software process has two parts, software development and software maintenance. The development process
consists of phases,
software feasibility study,
software analysis, software design, software implementation, and lastly, software testing. In the feasibility study, we ask ourselves should we proceed or not with the proposed project? Is it worth it? In the analysis phase, we describe in detail
the problem requirement.
In the design phase, we produce a high quality solution to that problem.
In the implementation, we implement the solution in testing, we assess all the software qualities to make sure that we are solving the right problem. In the maintenance process,
we have seen this earlier,
which means fixing bugs,
improving existing features,
or adding new features.
The software process
consists of the production activities and the management activities.
Production activities consist
of Analyze the problem requirement as given by the customer. The problem requirement have two parts, the functional requirement and the software qualities build
the high level software architecture. Refine the architecture until
we reach the solution.
Evaluate the software and the qualities, write the user documentation deployed to the customer. Environment provides support for
the end users and
maintenance for the customer.
the management activities
include conducting
the software feasibility study to make sure that it is worth developing the new application plan and schedule or the development task. Estimate the total cost by considering the required resources to develop the new application. Coordinate the work among the developers,
even when they are scattered in different locations. Identify and manage possible risks
that might delay the software development.
Track the progress in
each phase to make sure we meet the deadline.
practical disasters
Year 2000 problem
two problems for 2000.
The first one is that years are represented by two digits in the program.
Year 2000 will be confused with the year 1,900 The second problem is about getting the Lip year wrong.
What is the Lip year?
A leap year has two properties. The first one, it is divisible by four and not by 100. And the second property is that it happens every four years. The year 2000 is a leap year because of the four year period.
But on the other hand,
2000 is divisible by 100.
This is the first time in 400 years that a year divisible by 100 is a leap year.
But the program will test that 2000 is not a leap year. What is the solution? We just need to add property divisible by 400 in the condition why solving
the year 2000 problem was highly expensive. We have some reasons here. The first one is that the code was not available or doesn’t compile. We have
very poor modularity within the program, which means testing the Lip was not isolated in one single function. Therefore, locating all the Lipa conditions required a huge effort, which is measured here in terms of the number of lines of code.
