User Tools

Site Tools


apmdd:spring2016

Course "Programming automation" (PA)

The course is delivered to MIPT DIHT first year graduate students in Spring 2017 as an alternative course.

Professor: Anton Khritankov (contact: prog.autom (at) gmail.com)

Course Syllabus

Course includes five major topics that automate software development:

  • model driven software development (MDSD) via generic modeling techniques (e.g. Executable UML, xtUML etc.)
  • MDSD via domain-specific models (DSM)
  • model-based testing (MBT)
  • machine learning in software engnieering
  • industrializing model-driven development in software factories

Lectures are complemented with three labs:

  • UML Basics lab introduces students to UML modeling
  • in xUML Lab students develop a sample application using model-driven technology with UML
  • in DSL Lab students build a metamodel and implement a custom domain-specific language

There are 32 lecture hours and 16 lab hours in the course (a 2-hour lab each two weeks).

Course starts 16.02.2017.

Extended course syllabus can be downloaded here (in Russian).

Exam questions from year 2014 can be found here (in Russian)

Schedule

Schedule will be adapted to project needs.

#TopicProject topics covered
1Introduction to Model-Driven Software Development General
2UML 2. Classes. Review UML
3UML 2. Statecharts. Review UML
4Executable UML. Code generator
5Foundational UML (fUML). Action Language for fUML (ALF) UML
6Meta-modeling. Model-to-Model Transformation. Query-View-TransformationCode generator
7Developing Model-to-Text transformations Code generator
8Developing Domain-Specific LanguagesDSL
9Introduction to DSM and Domain-Driven DesignDSL
10Software product lines Reuse
11Applications of MDD. Software Factories. Embedded software. Case studiesTheory
12Software testing. Model-based Testing overview. Test generation Test generator
13Testing from state-based and rule-based models. Test generator
14Automatic Software Defect Prediction / Detection ML
15Course review. General

Individual assignments

Individual assignments are given throughout the course. A list of available assignments to choose from is TBD (e.g. read a paper). See also Model-Driven Software Development Library (in Russian)

Grading

There is a final exam for the course. Exam schedule will be announced later.

Unless “fast win” the final grade (FG) includes:

  • exam - 75%
  • individual assignments - 25%

If you complete a Fast Win project:

  • exam - 25%
  • individual assignments - 25%
  • fast win - 75%

(sum is 125%)

Students with Fast Win > 7 before exam may skip the exam.

Fast wins

Fast win is an assignment, completion of which allows for getting the final grade.

Code generator

Topics: UML, Code generator

Implement an MDA tool chain for UML 2 using XMI, XML and Groovy as target platform. Follow the ideas of Executable UML.

Note: A proof-of-concept implementation (PoC) is sufficient

DDD framework

Topics: DSL, Code generator

Implement a DDD framework that generates Web pages and DB schema from ECore data model.

State-transition test generator

Topics: UML, Test generator

Develop a test generator tool from state machines that uses SCXML and support all-states coverage criteria. Assume that conditions and triggers are written in Java.

Functional test generator

Topics: DSL, Test generator

Develop a DSL for specifying use-cases and develop a functional test generator from models in this DSL

TODO: more projects will be added

Fast win evalutation

Fast wins are graded on a 1..10 scale.

A solution is graded 3 if the following holds

  • you can demonstrate the working program that solves the original task on a specific example you've prepared
  • source code of the program does not depend on the example
  • basic understanding of how program works

A solution is graded 6 if the following holds

  • the program solves the original task without you overseeing it on a couple of different examples, some of which prepared not by you
  • implementation uses knowledge from the course program
  • throughout understanding of program internals and ability to quickly solve any errors

A solution is graded 9 if the following

  • the program solves the original task on many valid examples including unknown and handles errors gracefully
  • implementation uses knowledge from the course
  • throughout understanding of program internals and ability to promptly introduce any feasible modifications to the program on demand

Intermediate gradings are given if only some of the requirements stated above are fulfilled

Use of any third-party libraries, applications or code in addition to the specified in the assignment is subject to approval from your TA or Professor.

Personal contribution to the solution of the assignment shall be significant and demonstrate your skill and knowledge of the course material.

Course books

Main books:

  1. Mellor S.J., Balcer M.J. Executable UML. A Foundation for Model-Driven Architecture
  2. M. Fowler. Domain-Specific Languages
  3. M. Utting, B. Legeard. Practical Model-Based Testing. A Tools Approach

Additional books:

  1. Greenfield J., Kent S. Software Factories Assembling Applications with Patterns, Models, Frameworks, and Tools.
  2. Evans E. Domain-Driven Design Tackling Complexity In The Heart Of Software
  3. L. Bettini. Implementing Domain Specific Languages with Xtext and Xtend
  4. L. Starr, Executable UML How to Build Class Models, 2001

Articles, Papers and Internet sources

apmdd/spring2016.txt · Last modified: 2017/02/10 00:38 by user