1. Embedded Systems Software Engineering
Jarosław Kuchta
Embedded Systems Software Engineering
Agile Programming
GUT - INTEL 2015/16
Embedded Systems Software Engineering

2. Classic methods weaknesses
Large overhead for documentation
Concrete results are lately achieved
It is difficult to specify requirements at the early project stage
Developers loose a contact with the client for a long time
User requirements meeting is not guaranteed
GUT - INTEL 2015/16
Embedded Systems Software Engineering

3. Embedded Systems Software Engineering
Agile programming
Agile Manifesto
Individuals and interactions over processes and tools
Working software over comprehensive documentation
Customer collaboration over contract negotiation
Responding to change over following a plan
GUT - INTEL 2015/16
Embedded Systems Software Engineering

4. 12 principles behind Agile Manifesto (1)
Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.
Welcome changing requirements, even late in development. Agile processes harness change for the customer's competitive advantage.
Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.
Business people and developers must work together daily throughout the project.
Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.
The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.
GUT - INTEL 2015/16
Embedded Systems Software Engineering

5. 12 principles behind Agile Manifesto (2)
Working software is the primary measure of progress.
Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.
Continuous attention to technical excellence and good design enhances agility.
Simplicity--the art of maximizing the amount of work not done--is essential.
The best architectures, requirements, and designs emerge from self-organizing teams.
At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.
GUT - INTEL 2015/16
Embedded Systems Software Engineering

6. Embedded Systems Software Engineering
Agile Methods
XP Programming
Scrum
Feature Driven Development
Test-Driven Development
Lean Software Development
Dynamic Systems Development Method
GUT - INTEL 2015/16
Embedded Systems Software Engineering

7. Embedded Systems Software Engineering
Software life cycle
GUT - INTEL 2015/16
Embedded Systems Software Engineering

8. Extreme Programming Rules(1)
Planning
Write user stories
Create release plan
Plan short, frequent iterations
Plan each iteration just before it starts
Management
Create open space for developers
Ensure sustainable work pace
Organize short meetings at the beginning of working day
Measure project speed with implemented user stories
Move people between various tasks in the project
Tread schedule flexible
Design
Use simple solutions
Select proper system metaphor (proper naming)
Implement only simple solutions for selected problems
Do not add too much functionality too early
Reuse and refactor code
GUT - INTEL 2015/16
Embedded Systems Software Engineering

9. Extreme Programming Rules(2)
Coding
A customer is always available
Code must keep standards
Write unit tests before function coding
Pair-programming (two developers at one console)
Setup dedicated machine for code integration
Only one pair integrates code at each time
Code ownership is collective
Testing
All code must be covered by tests
All code must pass the tests
After an iteration, code must past acceptance tests based on user stories
If an acceptance test unveils an error, a new unit test must be written and all tests should be rerun
GUT - INTEL 2015/16
Embedded Systems Software Engineering

10. Embedded Systems Software Engineering
SCRUM
Sprints - short iterations
Only 2-4 weeks for one sprint
Three roles:
Product Owner
Scrum Master
Team (utterly self managing)
Product Backlog
Sprint Planning
Sprint Backlog
Short daily meetings (scrums) – 15 min
Sprint Review
"Scrum process" by Lakeworks
Licensed under GFDL via Commons - wiki/File:Scrum_process.svg#/ media/File:Scrum_process.svg
GUT - INTEL 2015/16
Embedded Systems Software Engineering

11. Testing in agile programming
New or modified code cannot be placed in repository until it passes all the tests.
Only under this condition effective team work is possible.
Acceptance tests are designed basing on user stories.
A user should describe test scenarios.
One user story may have many acceptance tests.
No user story is considered to be implemented until it passes all the acceptance tests.
GUT - INTEL 2015/16
Embedded Systems Software Engineering

12. Agile programming characteristics
Pros
Cons
Time effective (only development & testing)
Easily fitted to requirements changes
Can be used when requirements are unknown
Process depends on people – risk of team change
No possibility to return to the project after a long break - lack of documentation
The possibility of serious design errors (e.g. special and emergency situations)
High cost of changes during software usage
GUT - INTEL 2015/16
Embedded Systems Software Engineering

13. Embedded Systems Software Engineering
Conclusions
Agile Programming is more effective than classic methodologies (e.g. RUP),
Agile Programming can assure software quality under some key conditions.
Agile Programming usage:
Simple applications
Low risk at project failure
Continuous product maintenance
GUT - INTEL 2015/16
Embedded Systems Software Engineering

14. Key conditions for quality
Close cooperation (communication) with customers in the whole development time.
Release objectives based on real customers’ needs.
Keeping good engineering practices.
Keeping a schedule of frequent releases (a continuous work in the same project)
Reliable unit test writing and test passing before each release.
Passing acceptance tests based on real usage scenarios.
GUT - INTEL 2015/16
Embedded Systems Software Engineering

15. Embedded Systems Software Engineering
Sources
Kent Beck: Extreme Programming Explained: Embrace Change, Addison- Wesley, 1999
GUT - INTEL 2015/16
Embedded Systems Software Engineering