Software engineering is the systematic application of engineering approaches to the development of software in a rigorous way. Software engineering is a direct sub-field of engineering and has an overlap with computer science and management science. It is also considered a part of overall systems engineering.
What is a computer? Computer is a programmable device. The essence of computing is programming. So programming development is the most essential use of the computer. Software engineering investigate programming development, how to do it efficiently and reliable.
It not only involves technical requirements but looks at who are the stakeholders and what are their needs and the end goal.
How is software engineering different from programming? Programming is all about the create part of software. Sofwware enginering is about whole life cycle and quality. issues long after you ship, which is ht elargest piece of sofware development. Value creation process.
Large and complex systems. World depends on software.
Why is it so hard to build software? It crashes all the time.
Methodologies
Techniques
Tools
High Quality Software that works and fits budget
Three problems:
1. Rising Demand of Software
There's a software crisis in 1960s. Land on the moon, first Polaroid picture. Rising demand of software where there's a transition from hardware to software.
Growth in NASA's and Boeing's software demand exponential.
Software everywhere, software eating the world. Marc Andreessen famously said that “Software is eating the world” and everyone gushed into the room.
2. Increasing Product Complexity.
Development Effort in lines of code (LOC):
Size LOC Example
100 Class project ]Programming effort
1,000 Small project ]Programming effort
10,000 Term project ]Programming effort
100,000 Word processor ]Software engineering effort
1,000,000 Operating system ]Software engineering effort
10,000,000 Distributed system ]Software engineering effort
Each software by a factor of:
10^2 LOC
10^3 LOC
10^4 LOC
10^5 LOC
10^6 LOC
10^7 LOC
3. Slow developer productivity growth
a developer can't keep up with rising software size and complexity. Gap between what's needed and what's available.
So, software can be delivered but never used because it doesn't work properly or doesn't accomplish its goal. Software can be still usable after changes.
Software Development has to be systematic
Software Process:
Waterfall - from one phase to another
Evolutionary prototyping - no rigid steps, evolve based on feedback from customer
RUSP rational unified process (USP) based on UML
Agile - sacrifice discipline to be flexible and account changes in requirements
Software engineering LifeCycle phases:
Requirements Engineering - what kind of system, who are the stakeholders and what needs the software solves
Design - details of software system
Implementation - write code of design
Verification and Validation - code behaves as intended
Maintenance for bugs - eliminate bugs or add new functionality
Tools & automation of the Trade:
Essential for efficiency and effectiveness.
software size and complexity vs developer productivity - close the gap with tools
Examples
Development - punch cards vs IDEs.
Languages - machine code vs high-level languages
debudding - print lines vs symbolic debuggers
Tools:
IDE, advance editors, to compile, run, debug, test
Git, version control systems
Coverage & verification tools during testing
Requirements Engineering
-eliciation
-analysis
-specification
-validation
-management
Design
Activities vs Design Products
-Architectual design -- System structure
-Abstract specification -- Software specification
-Interface design -- Interface specification
-Component design -- Component specification
-Data Structure -- Data Structure specification
-Algorithm -- Algorithm specification
Implementation
Reduction of complexity
Anticipation of diversity - construction might change over time
Structuring for validation - easy to test
Use of internal or external standards - medical software regulations HIPPA
Verification & Validation
Validation - Did we build the right system?
Verification - did we build the system right?
Unit--Integration--System
Maintenance
Environment change - adaptive changes
Features request - perfective changes
Bugs - corrective changes
SOFTWARE PROCESS MODEL
Water fall process
At each stage you review if project is ready to advance to next phase
Software concept --> requirement analysis --> architectural design --> detailed design --> coding & debugging --> systems testing
performs well where there's clear production definition. allows you to find errors early on to reduce cost. Not flexible. Not good for engineers that don't know how to build the product. Not ideal for most real world projects.
Evolutionary Prototyping
Start working on the parts of the system developers understand