Syllabus for the class

[dejanpan]

@Ly0n sorry for being late, but this is my proposal for the first lecture of Autoware Class. LMK if it sounds OK.

Outline

The students will in this class learn three different things: a) the overview of the class to be unfolded, b) the development environment in which they will be able to reproduce the labs and c) the details of the methods needed to develop software for the safety critical systems.

Image

Syllabus

Part 1

1. Class intro (Dejan)
   1. Teacher intro
   2. Autoware in a video: https://www.youtube.com/watch?v=kn2bIU_g0oY&feature=youtu.be
   3. Why are we offering this class
   4. What will the students learn
   5. How will the students learn
2. Brief history of Autoware
3. Walk through the syllabus
4. Quick start - development environment
   1. HW prerequisites
   2. Install ADE
   3. Install ROS 2
   4. Install Autoware.Auto
   5. Run object detection demo
   6. Edit and compile your code

Part 2

1. Development of complex and safety critical software - the theory (Tobias)
   1. Popular development models (V-model, Waterfall, Agile)
   2. Software architectures (e.g. separation of concerns)
   3. Community
   4. Communication
   5. Safety and Security: https://gitlab.com/autowarefoundation/autoware.auto/AutowareAuto/-/issues/206
2. Development of complex and safety critical software - the practice
   1. Software development workflow in Autoware.Auto:
      1. https://autowarefoundation.gitlab.io/autoware.auto/AutowareAuto/cpp-development-process.html
      2. https://autowarefoundation.gitlab.io/autoware.auto/AutowareAuto/develop-in-a-fork.html
   2. Designs and Requirements: https://www.apex.ai/post/building-safe-algorithms-in-the-open-part-1-design
   3. Testing (Validation):
      1. Unit testing: https://autowarefoundation.gitlab.io/autoware.auto/AutowareAuto/how-to-write-tests-and-measure-coverage.html
      2. Integration testing: https://github.com/ros2/launch/tree/master/launch_testing#launch_testing and https://autowarefoundation.gitlab.io/autoware.auto/AutowareAuto/integration-testing.html
      3. Structural Code Coverage
   4. Static code analysis: https://autowarefoundation.gitlab.io/autoware.auto/AutowareAuto/how-to-write-tests-and-measure-coverage.html#how-to-write-tests-and-measure-coverage-static-code-analysis
   5. Testing (Verification): Planned for the future https://discourse.ros.org/uploads/short-url/yc1H3yPx3yw0QhH25NZYEAG6Xul.pdf
   6. DevOps: https://gitlab.com/autowarefoundation/autoware.auto/AutowareAuto/-/blob/master/.gitlab-ci.yml
3. Conclusion and the next lecture

[dejanpan]

@Ly0n for 5.ii we internally use these guidelines:

General design

System and software architecture principles help programmers develop code that conforms to safety-critical software principles, i.e., code that does not contain defects and that could lead to catastrophic failures resulting in significant harm to individuals or damage to property. In general, safety-critical code must exhibit the following important qualities:

1. Reliability: executable code consistently fulfills all requirements in a predictable manner
2. Portability: source code is portable (i.e. not compiler or linker dependent)
3. Maintainability: Source code is written in a manner that is consistent, readable, simple in design, and easy to debug
4. Testability: source code is written to facilitate testability; minimizing the following characteristics for each software module facilitates a more testable and maintainable module:
   5. Code size
   6. Complexity
   7. Static path count: the number of paths through a subset of the application code
5. Re-usability: the design of reusable components is encouraged. Component reuse can eliminate redundant development and test activities (i.e. reduce costs)
6. Extensibility: requirements are expected to evolve over the life of a product. Thus, a system should be developed in an extensible manner (i.e. perturbations in requirements may be managed through local extensions rather than wholesale modifications)
7. Readability: source code is written in a manner that is easy to read, understand, and comprehend

Note that following the guidelines contained within this document do not guarantee the production of an error-free and safe product. However, adherence to these guidelines helps programmers produce clean designs that minimize common sources of errors.

Source: http://www.stroustrup.com/JSF-AV-rules.pdf

[Ly0n]

@dejanpan,

your proposal for the Syllabus looks great.
This repository was more a retrospective for myself on the experiences I made over the last years.
I will create a new document in the autoware.auto repo and reuse the parts like you proposed.