IT-Universitetet i København
 
  Tilbage Kursusoversigt
Kursusbeskrivelse
Kursusnavn (dansk):Model Driven Development Project 
Kursusnavn (engelsk):Model Driven Development Project 
Semester:Forår 2015 
Udbydes under:cand.it., softwareudvikling og -teknologi (sdt) 
Omfang i ECTS:7,50 
Kursussprog:Engelsk 
Kursushjemmeside:https://learnit.itu.dk 
Min. antal deltagere:
Forventet antal deltagere:55 
Maks. antal deltagere:100 
Formelle forudsætninger:This course assumes that you are a confident software developer, knowledgeable in programming language paradigms and concepts, and that you are able to work with (moderately) complex development projects yourself. These abilities can normally be obtained by following a bachelor programme in software development.

Concretely:

- You efficiently use object oriented programming constructs and concepts such as classes, encapsulation, inheritance, polymorphism, interfaces, exceptions.

- You know Java programming language (we do not program in Java in this course, but we read and generate Java code regularly)

- You can independently use existing libraries and code implemented by others, following available documentation

- You know basic UML class diagrams notation, basics of XML technology, the relational data model and the SQL language

- You use basic constructs of declarative functional programming, in particular anonymous functions and higher order functions

- You can manipulate standard data structures such as lists, trees and graphs. You have basic working knowledge of complexity and algorithms, including dynamic programming

- You know basic programming language concepts, and implementation techniques (grammars, abstract and concrete syntax, parsing, interpretation and compilation). This can be gained following a compiler course, for instance "Programming Language Concepts and Implementation"

- You are comfortable using Eclipse as your development environment (or a similarly mature tool, for instance IntelliJ)

- You can read professional computing literature; you have read research papers and books about programming before (this can be gained in almost every SDT course; or by trying to read a few papers before the course commences)

- You know the basic of software engineering processes and quality assurance, for instance having followed an introductory software engineering course (this can be gained following the course "Software Engineering and Software Quality")

- You know the basics of software testing and can implement and execute unit tests (using JUnit or one of the similar frameworks)

Moreover the student must always meet the admission requirements of the IT University.
-----
Information about study structure
SDT
This course is mandatory for students admitted on the Advanced Computing track on SDT.

The course is usually not suitable for the Design track students. You are welcome to joined if you feel that you fulfill the prerequisites to the high degree.

-----
Information om studiestruktur
Dette er et obligatorisk kursus på masteruddannelsen i Softwarekonstruktion. 
Læringsmål:After this course you should be able to:

- Create object-oriented domain models and meta-models (this is a reinforcement of your object-oriented modeling skills in languages like class diagrams)

- Use modeling as a tool to comprehend legacy code

- Re-engineer legacy code to model driven architectures

- Design and implement internal and external domain specific languages

- Describe the main techniques used for domain modeling and implementation (domain specific languages, modelling frameworks, transformation languages, code generators, concrete syntax and models)

- Perform domain analysis of a problem domain, obtaining a meta-model expressed as a class diagram.

- Use object diagrams to present early stage examples of models, and used abstract syntax representations to manipulate models programatically

- Design and improve concrete textual syntax for modeling languages.This includes writing and refactoring context free grammars, eliminating left-recursion, etc.

- Implement declarative constraints and type rules for domain specific languages.

- Implement declarative and imperative model transformations, code generators and interpreters, in various scenarios such as from text to models, from models to text, involving XML, database, etc.

- Implement modeling languages efficiently using mode-driven development tools (Xtext framework).

- Test implementations of modeling languages

- Program in a modern JVM language using functional programming concepts such as anonymous functions, closures, higher order functions, extension methods, dynamic method overloading, and type inference (we are presently evaluating the choice of the language between Xtend and Scala; the choice will be communicated in the course)

- Use complex industrial strength frameworks (by having experienced work with, for example, OSGi, EMF, GMF, XText and other components of the Eclipse platform)

- Compare and contrast related data representation technologies: meta-modeling stack of OMG, XML technologies of W3C, Database modeling and representation technologies, grammar based language representation technologies.

- Characterize, classify and compare programming and modeling languages along a host of properties. 
Fagligt indhold:The goal of this course is to give you a mindset of working with software in an abstract and semi automated fashion, as in a production process (as opposed to a hand crafting process).
This is achieved by introducing modeling languages and models as first class artifacts that are designed, manipulated, transformed and translated to code in an automatic fashion.

Subjects will include

- Domain-modeling, feature modeling, meta-modelling and design of domain specific languages

- Concrete Syntax, and concrete syntax editors

- Architecture modelling, product line architectures, variability modeling

- Structural constraints

- Model Transformation and code generation

- Implementation of domain specific languages using generic tools 
Læringsaktiviteter:14 ugers undervisning bestående af forelæsninger og øvelser

16 weeks semester containing approximately 28 hours of lectures, 20 hours of tutorials and a project with supervision.

Most of the learning happens in exercises and in a project which is implemented in a 4-person team. You are expected to meet for the supervision meetings during the project.

The project part of the course accounts for about 40% of the workload.

All the tools used in the course are free for you to use, so we expect you to work on your own computer.


----------
See the course schedule here:
link to the time table
The schedule will be ready shortly before the beginning of the term.
----- 

Obligatoriske aktivititer:Content

Workload

Activities
There are 8 simple mandatory assignments graded PASS/FAIL. Every student must pass six of these assignments.

There are strict deadlines for these assignments. There are two ways for you to retry them: First, you can miss two of the assignments freely. Second, in the end of the semester there will be an addition compassion deadline, when you can hand in again
failed assignments, and those that you did not manage to hand in on time.

Feedback

What if the student fails to pass a mandatory activity:

Be aware: The student will receive the grade NA (not approved) at the ordinary exam, if the mandatory activities are not approved and the student will use an exam attempt. 
Eksamensform og -beskrivelse:X. experimental examination form (7-scale; external exam)

individual responsibility for answers to the examiner's questions.

Each student is guaranteed 40 minutes of preparation time (in isolation) before answering questions in the oral exam. You can access your notes and books during preparation, but you should not use Internet. The actual oral exam lasts 30 minutes including start up, questioning, deliberation, and feedback.

The hand-in (project implementation) is part of the exam and it is required to qualify for the exam. The quality of the project is assessed in the exam, influencing your grade (this includes the quality of your code, language design and software architecture of the solution). We will explain how to prepare the project submission for grading during the semester (it will be published on LearnIT).

There is no project report.

As an indication, the project weighs 40% and the oral exam performance weighs 60%. However, be advised that you are graded against the list of skills listed above in the course description, so this percentages are only indicative. The examiners need to be
convinced that you have operationalized the intended learning outcomes. This normally means that you have created a functioning project and can knowledgeably answer questions about the techniques (including demonstration of their use on site in the exam room).  

Litteratur udover forskningsartikler:Lecture notes and online material provided in LearnIT. Examples of
additional books that are relevant:

Lorenzo Bettini. Implementing Domain-Specific Languages with
Xtext and Xtend. 2013

Martin Fowler. Rebecca Parsons. Domain-Specific Languages.
Addison-Wesley 2011.

T. Stahl, M. Völter: Model-Driven Software Development:
Technology, Engineering, Management. Wiley (2006)

Torben Mogensen. Introduction to Compiler Design. Springer 2011.

Peter Sestoft. Programming Language Concepts. Springer 2012

Richard C. Gronbach: Eclipse Modeling Project. A Domain-Specific
Language (DSL) Toolkit. Addison Wesley (2009)

Martin Odersky, Lex Spoon, Bill Venners. Programming in Scala.
Artima Inc. 2008

Cay S. Horstmann. Scala for the impatient. Pearson 2012.

None of these books is our main textbook, so you should not automatically buy them. I recommend waiting until you see that you need them (and they should all be available as ebooks, without waiting for delivery, if you need them).