System modeling, Software engineering, Object-oriented programming

A kötelező előtanulmányi rend az adott szak honlapján és képzési programjában található.

The course aims to present the foundational processes and techniques of model-based systems engineering. It includes the basics of requirements specification and modeling, system modeling with functional and extra-functional viewpoints, platform/infrastructure modeling, model-based deployment, various processes and techniques of verification and validation (e.g. static analysis, testing) and the role of automated model transformations and code generators (generation of tests, source code, configurations, deployment descriptors, documentation, monitors). Case studies of the course will be taken from embedded systems built by integrating intelligent components.

Students successfully completing the course will be able to :

1. precisely capture requirements of IT systems including requirements of their operational context, structure and behavior, architecture and execution platform;

2. learn the main concepts and usage of most important standard system modeling languages;

3. learn verification and validation techniques of systems engineering (testing, static analysis etc.),

4. develop complex IT systems using a model-based approach by systematically using automated code generators.

Week 1-2: Foundations of systems engineering; Requirements engineering

Concepts of model based systems engineering (development processes, requirements, languages, models, verification and validation), engineering processes (V model vs. agile development), dependability.

Functional and extrafunctional requirements: modeling and analysis. Concept of traceability.

Week 3-4: Structural and behavioral modeling,

Structural models: architecture and component design, well-formedness constraints, interface and datatype design, inter-component communication paths, code generators for static models  

Behavioral models: state-based behavioral models of components, dataflow models, scenarios; code generators for behavioral models.

Week 5-6: Platform and Infrastructure modeling 

Platform and infrastructure models: Component based integration techniques, system partitioning, infrastructure models, distributed architectures, Modern platforms (case studies): AUTOSAR, MARTE, Cloud

Foundations of fault tolerance – fault, error, failure, availability vs reliability, types and role of redundancy, fault-tolerant design patterns, links with deployment

Week 7-8: Extrafunctional analysis and optimization, Modell-driven deployment

Model-driven deployment: addressing extrafunctional requirements (performance, throughput, capacity estimation, resource allocation, timeliness: WCET, schedulability, availability, optimization), robust partitioning, automated synthesis of deployment descriptors and configuration files

Week 9-10: System verification and validation 

Testing of critical components: unit testing (JUnit), static source code analysis (FindBugs, PolySpace), isolation (stub, mock), test coverage (MC/DC).

Model based test design (integration, function, extrafunctional): static consistency checks (completeness, consistency, determinism), statemachine based test generation and verification techniques.

Week 11-12: Model transformation and code generation

Model transformation: role and categorization, main approaches, graph based techniques.

Code generators: categorization, template based code generators (e.g. Acceleo / Xtend).

Week 13-14: Case studies

Model based engineering in critical embedded systems (e.g. automotive, avionics, cyber-physical systems)

Engineering and deployment of business-critical systems

Practice lessons:

Students will need to design a complex system including the following phases: 

·         Requirements analysis: capturing requirements, traceability.

·         System modeling: structural and behavioral models.

·         Platform and infrastructure models

·         Model-driven deployment

·         Model based testing

·         Code generation and model transformation.

During practice lessons, consultation will be offered to students to assist them completing their homework assignment.

21*2 hour of lecture and 7*2 hour of practice lessons (working in small teams) equally distributed throughout the semester.

·      During  the term: a homework assignment of designing a complex system (modeling + implementation) where each subtask is completed and graded separately.

·      During examination period: written exam.

·      The course is acknowledged upon the completion of the homework assignment with a satisfactory grade

·      Further optional homework assignements will be offered by the lecturers of the course.

·      Final grading will consist of the grades of the written exam, the homework assignment, and optional homework assignment.

The homepage of the course will contain course material including annotated slides of lectures, white papers, case studies and manuals and video presentations of tools.

Additional electronic material will be provided during the semester

Recommended reading: 

·         M. Brambilla, J. Cabot, M. Wimmer: Model driven software engineering in practice.

·         Sebastien Gerard; Jean-Philippe Babau; Joel Champeau (eds): Model Driven Engineering for Distributed Real-Time Embedded Systems. 

·         J. Hudak, P. Feiler: Developing AADL Models for Control Systems: A Practitioner’s Guide (Technical report)

 Related OMG standards: SysML, UML MARTE profile