0x010088F6312065A70A44B630A6848498EAD80093CFEAFE161DC94D83C7C5C9A5A748B8

The course is organized in classical lectures, practical lectures, individual assignments and group project work. Some changes have been introduced this year, mainly in the organization of how the course and assignments are developed. <ul><li>In the previous year students were able to select the topic of the project. This year the same common project topic was given to all the students in the course, with the objective to provide a topic that is more focused on the objectives of the course. The course coordinator thinks that this solution worked better and that it enabled a more fair evaluation across the groups.</li></ul> <ul><li>Some pre-recorded videos as guidance for the tools adopted in the course have been created, and they proved to be very useful. The videos don't cover the entire course yet, and should be further developed in the next versions of the course. This was suggested by students from 2022.</li></ul> <ul><li>GitHub Education was used as the platform to host the assignments and project of students. This worked well and simplified the management of the repositories of students, including providing feedback.</li></ul> For the future versions of the course, alternative tools could also be considered, at least as a complement to those based on Eclipse. In earlier versions of the course the Langium tool for VSCode was mentioned, which however covers only a part of the course topics. The EMF.Cloud project promises to move EMF-based tools to the cloud and it should then be monitored. Other alternatives like MPS can be considered, although they have a very narrow scope. Some students mentioned that the description of the course and the name itself are not very well aligned with the content. Possibly, a better wording should be considered.

The course is organized in classical lectures, practical lectures, individual assignments and group project work. In the previous year students were able to select the topic of the project. This year the same common project topic was given to all the students in the course, with the objective to provide a topic that is more focused on the objectives of the course. The course coordinator thinks that this solution worked better and that it enabled a more fair evaluation across the groups. Students feel that the is too focused on Java and on the Eclipse platform, which are however still a suitable choice because of their openness and relevance for MDE tasks. Some of the tools are however not well maintained and not so easy to use, as they require specific usage workflows and configuration. The documentation of the wiki of the course, hosted at https://www.ntnu.no/wiki/display/tdt4250/ is of great help, although some parts need maybe to be updated. This year some pre-recorded videos as guidance for the tools adopted in the course have been created, and they proved to be very useful. The videos don't cover the entire course yet, and should be further developed in the next versions of the course. The evaluation of the course was done with a reference group composed of two students. Besides that, informal feedback with students was obtained during the hours in which supervision for the project took place. The students mention that the topics in the course are interesting and that they are something completely different from what they saw before. The main challenge in the course are the tools, which are not well documented and it is also sometimes difficult to get the "big picture" of what tools are used for what task. Concerning learning outcomes, a revision of the course description and/or content could be considered. Students perceive this course as a "continuation" of the software architecture course and suggest to put more focus on the modeling and less on the tools. More emphasis should be put on accelerating software development through models. Having a unique project topic worked well, but the project specification was perhaps too broad and it was not always clear which technique to use for which part of the project. Students suggest that a possible alternative is to allow students to define their own project, but provide fixed guidelines and constraints. A supervision slot of two hours was offered weekly for help with the project. This was appreciated by the students as reported by the reference group.

The course would benefit of at least two teaching assistants, to supervise the groups and to go through their projects. Unfortunately it seems particularly challenging to find TAs for this course.

NTNU:TIA:REST

Institutt for datateknologi og informatikk

Department of Computer Science

Engelsk

Mer om vurdering

Mappen består av en eller flere oppgaver (som teller 30 % av karakteren) og et semesterprosjekt (som teller 70 % av karakteren). Oppgavene er individuelle om spesifikke temaer, mens prosjektet utvikles i grupper på 3-4 studenter og det er ment å demonstrere kompetanse om det overordnede innholdet i emnet.Den obligatoriske øvingen går ut på å definere prosjektet. Dette gjør gruppene selv med veiledning fra lærer. Tilbakemelding og veiledning for prosjektet vil bli gitt gjennom semesteret.

Anbefalte forkunnskaper

Emne TDT4100 Objektorientert programmering, eller tilsvarende. Emne TDT4140 Programvareutvikling, eller tilsvarende. Emne TDT4175 Informasjonssystemer, eller tilsvarende. Emne TDT4240 Programvarearkitektur, eller tilsvarende.

Faglig innhold

Generelle teknikker for modellering, design og realisering av modulær programvare, med fokus på industrielle teknikker og anvendelser. Komponentbasert design, komponentbaserte arkitekturer og rammeverk, distribuerte komponentbaserte systemer. Modell-drevet utvikling av programvare, kode-generering og domenespesifikk språk. Testing, kontinuerlig integrasjon og forvaltning.

Kursmateriell

Læringsutbytte

Kunnskaper: Studenten skal kunne generelle metoder for modellering, design og realisering av modulær programvare og modell-drevet utvikling av programvare, og hvordan disse brukes i ulike faser av utvikling og vedlikehold. Ferdigheter: Studenten skal ha praktiske ferdigheter i modellering, design og realisering modulær programvare, med moderne rammeverk og verktøy, også med modell-baserte teknikker. Generell kompetanse: Studenten skal kjenne til og kunne velge mellom ulike metoder og teknikker for utvikling av modulær programvare.

Læringsformer og aktiviteter

Forelesninger, øvinger og prosjekt under veiledning.

Øvinger

Avansert programvaredesign

Datateknikk

Informatikk

Teknologiske fag

Datateknologi - masterstudium (2-årig)

Industriell økonomi og teknologiledelse - masterstudium (5-årig)

Datateknologi - masterstudium (5-årig)

Master of Science in Informatics

Web/Lists(guid'8b698a2d-6ad0-4f7d-b3be-219cc1979f02')/Items(26498)/FieldValuesAsText

This is the first year that the course was completely in presence, after two years of remote or partially remote teaching. Still, also this year lectures were recorded and made available to students, also to be able to switch again to remote if needed. However, this has probably not encouraged students to attend lectures, and so students attending were much less than those actually enrolled in the course. The course is organized in classical lectures, practical lectures, individual assignments and group project work. The topic of the project is left open, so that students can engage in defining their own objective (within the context of the course). Leaving the project open worked well for some groups, but not so well for others, which instead defined the topic of the project quite late in the semester, and with a perhaps too narrow scope. To solve this problem, some option could be considered, like a common project for the semester (with possibility of defining a custom one) or defining an earlier deadline for groups to define the objective of their project. The combination of individual assignments and project worked well and it should be maintained. Students feel that the is too focused on Java and on the Eclipse platform, which are however still a suitable choice because of their openness and relevance for MDE tasks. Some of the tools are however not well maintained and not so easy to use, as they require specific usage workflows and configuration. The documentation of the wiki of the course, hosted at https://www.ntnu.no/wiki/display/tdt4250/ is of great help (as mentioned also in the reference group report), although some parts need maybe to be updated. Some students suggested to have some pre-recorded videos in which the usage of the tools is explained. Alternative tools could also be considered for the next versions of the course, at least as a complement to those based on Eclipse. In previous versions of the course the Langium tool for VSCode was mentioned, which was however not used this year. The EMF.Cloud project promises to move EMF-based tools to the cloud and it should then be monitored. Other alternatives like MPS can be considered, although they have a very narrow scope. However, it appears also that some students do not have the required background, as they lack basic skills in object-oriented programming and/or have never used Java. Also, many students had problems in using git and in interacting with GitLab; perhaps some links to tutorials should be provided in the beginning of the course. Some students mentioned that the description of the course and the name itself are not very well aligned with the content. Possibly, a better wording should be considered.

Concerning course administration, it was not easy to enroll students for the reference group, and in this case only one Erasmus student was part of the reference group. He did however a good job of interacting with the other students, and provided detailed comments and feedback (even if not all of them are listed in the group report). The course would benefit of at least two teaching assistants, to supervise the groups and to go through their projects. This year the course had no TAs at all.

Norsk

Mappen består av en eller flere oppgaver (som teller 30 % av karakteren) og et semesterprosjekt (som teller 70 % av karakteren). Oppgavene er individuelle øvelser om spesifikke temaer, mens prosjektet utvikles i grupper på 3-4 studenter og det er ment å demonstrere kompetanse om det overordnede innholdet i emnet. Målet med prosjektet er definert av gruppene selv, med veiledning fra lærer. Tilbakemelding og veiledning for prosjektet vil bli gitt gjennom semesteret.

Kunnskaper:Studenten skal kunne generelle metoder for modellering, design og realisering av modulær programvare og modell-drevet utvikling av programvare, og hvordan disse brukes i ulike faser av utvikling og vedlikehold.Ferdigheter:Studenten skal ha praktiske ferdigheter i modellering, design og realisering modulær programvare, med moderne rammeverk og verktøy, også med modell-baserte teknikker.Generell kompetanse:Studenten skal kjenne til og kunne velge mellom ulike metoder og teknikker for utvikling av modulær programvare.

Forelesninger, øvinger og prosjekt under veiledning. Kurset kan bli forelest på engelsk dersom det tas av studenter uten norskkunnskaper.

Web/Lists(guid'8b698a2d-6ad0-4f7d-b3be-219cc1979f02')/Items(21002)/FieldValuesAsText

These are the topics I've focused on concerning incrementally improving the course. Make the project more relevantThe project's topic has been made more open in recent years, to increase the perceived relevance, and the impression is that it has worked. This year, I tried to add "sustainability" as a topic, but it was hard for me and the students to find good domains and data sources that allowed then to use relevant techniques and methods. Modernize the technology platformThis is related to the previous topic, and the goal is the make the course (seem) more relevant. For many, modernizing means web development and cloud development and often (and unfortunately) non-java platforms. During the semester, I found the new Langium DSL framework for the VSCode (and Typescript) platform, so it was added as an alternative to Xtext for one of the project variants. That turned out well, as several groups chose to try it out and said they were happy to use (and extend) VSCode and code in Typescript. The disadvantage is that Langium isn't as strong as Xtext (yet), so less of relevant topics can be explored. But hopefully it will evolve and improve for next year. The tools for model-driven development are in general transitioning to web- and cloud-based platforms, i.e. tools run in a container and the front-end is web-based e.g. a web-based IDE like VSCode or Theia. We're not there yet, but during the semester, the web-based variant of Sirius has almost become good enough to be used in the course. The EMF Cloud initiative is important and should be tracked, see https://www.eclipse.org/emfcloud/. TextbookWe have previously tried to find and start using a (new) textbook. Previously, we have tried two books (for the model-driven engineering topics), "Model-driven Software Engineering in Practice" by Bambrilla et.al (https://www.akademika.no/model-driven-software-engineering-practice/brambilla-marco/cabot-jordi/wimmer-manuel/9781608458820) and "Model-Driven Software Development" by Voelter (https://www.voelter.de/data/books/mdsd-en.pdf). The first one covers many interesting topics, but is weak in the practice of the techniques and is less conceptual than I like. The second is more conceptual, but is harder to read and requires more experience in software modelling than the students have. A couple of years ago (just before the pandemic), a new book by Andrzey Wasowski and Thorsten Berger was announced, which looked promising (see http://dsl.design), but it isn't finished, yet (partly due to the pandemic, they said). It is now supposed to be due and should be considered. It looks promising, but has a more narrow scope than the course currently has, and diggs a bit deeper and goes further in a different (but relevant) direction.

<h2>Overview of the course</h2><h3>Contents</h3>In general the course is about modern techniques and methods for "industrialising" software development, interpreted as improving quality and speed while handling scale. Model-driven development (MDD) is the main topic, where models of the domain and/or software is play an important role. The other part is about component-based design (CBD), since it is key to handling scale by dividing a system into smaller interconnected parts. A common theme is automation, since both topics are about making systems and tools know more about what we as developers are doing, so software can do more for us. With MDD we use a modelling framework that is understood by tools that help us out, and we build languages and tools ourselves. I CBD, we declare more about the structure of systems so tools and frameworks can help us validate (to some extent), assemble and run systems. Although the MDD-topics are generic, e.g. object-oriented modelling, constraints, validation, transformations, code generation, grammars etc., we build upon the Eclipse Modeling Framework (EMF), since it is the most mature and feature-rich framework and eco-system. The tooling is Eclipse-based, and Eclipse can be the target to tools we build, but we can make systems based on EMF that don't require Eclipse at runtime. Among others, we show that code built upon an EMF-based model can be used in a REST service. The CBD-topics are generic, too, we discuss modularisation and service-oriented design, and illustrate and practice with OSGi, which is a compact Java-based framework and runtime for modular, dynamic java applications. Bnd(tools) is used for tooling, since it is best at making the most of the OSGi modules' meta-data. For both MDD and CBD we try to show how they can support development of real software. <h3>Lectures</h3>The lectures are partly theoretical, partly practical with "show and tell" of how to use methods and tools. The first part of the lectures introduce basic use of modelling (with EMF). The second part move on to domain-specific languages (DSLs), building upon the first part. The third part is about CBD, with OSGi as the main example technology. <h3>Assignments and project</h3>There is one MDD assignment split into two submissions with feedback in-between (10 and 15 percent of the final grade) where they model a domain (first part) and generate a web page from a model instance (second part). The domain can be chosen by them or they can use the domain of study programmes and courses. In both cases, the points of the assignment is to practice most concepts and features of EMF, so it's important that the domain is rich enough and the students try to make relevant use of the various EMF features. The submit the model first, and are allowed to improve it for the second submission, which also includes a transformation (typically model to text (M2T)) from an instance of the model to a web page. The project builds on the two first parts of the lecture series, and is about building a DSL or runtime based on a model. In general, I want to give the students a lot of freedom, but it's important to ensure they stay within the course topics, so I give them three suggestions. A Sirius-based DSL using data from a public source, an Xtext- or Langium-based DSL for software development and an EMF- and OSGi-based runtime for web system. They MUST discuss the chosen project with me in advance, and SHOULD show up for supervision, so I ensure they learn the most about relevant topics, and not just do things they consider relevant and fun. <h2>The students</h2>The students have various backgrounds, typically of three kinds. We have those enrolled in the five-year master of technology, with a predictable set of courses that we can build upon, and that typically take our course as part of the Software specialisation. Then we have those from various bachelor degrees with a less predictable course portfolio, and academically may have a weaker background. Finally, we have the exchange students that are even more diverse, but often have better background for modelling and formal thinking. These three groups of students to a certain degree follow a pattern. Very simplified, the first group don't show up for lectures or come to supervision, partly because they're sure they can manage on their own, partly because they have a lot to do in and give priority to the Customer-Driven Project course. The second group of students seem more interested (and less sure they don't need lectures or supervision), but can be less conceptually minded. The exchange students show up in class, take supervision, work hard, learn the most and seem most grateful. In general, students find MDD abstract and difficult, partly because they have little experience with UML modelling (EMF uses a small subset of UML class diagrams) in advance. Also, they have found little use of UML in practice and take time to understand why it is (supposed to be) different in this course. Eventually, after struggling a lot with Eclipse and EMF, they (often) agree that using EMF and generating code is quicker for implementing a data-oriented API. The project is an eye-opener for many, as that's when they see the relevance more personally, if they've chosen a topic they considered relevant, that is. At least, that was the main feedback this year, after they had submitted their project.It's difficult to make them understand the need for handling scale of a system with modularisation, since they have little experience with large systems last for long (they use such systems, but haven't built them). But at least they recognise many concepts when they are related to modern tool chains, and they appreciate learning about OSGi when they see how dynamic the system may be (restart parts and components disappear and re-appear). <h2>Issues with the course</h2><h3>Contents</h3>The course name suggest that the content should be dynamically updated to reflect contemporary topics and what is considered as "advanced". On the other hand, we want the course to include sustainable methods and techniques, not just currently hot topics (that often are reappearing old ones). The middle ground I have chosen is to try to relate the sustainable methods and techniques to contemporary software development and technology stacks, but it's difficult when e.g. modelling isn't used much in mainstream development (unfortunately).Ideally, the course' contents should be designed with input from the ISSE unit and aligned with other courses in an open process, perhaps this is a time to do that?<h3>Course material</h3>I haven't found a textbook that I like and that works. Bambrilla*s is too fluffy and weak on practicing methods and techniques, while Voelter's was too difficult to read. Currently, the course refers to various web resources from BB, uses material from the NTNU wiki @ https://www.ntnu.no/wiki/display/tdt4250 and examples in IDI's gitlab @ https://gitlab.stud.idi.ntnu.no/TDT4250. It would be easier for the lecturer and students to have a book, e.g. the new one on DSLs by Wasowski and Berger, but continuously evolving the course means no textbook will fit really well.

Noen individuelle vurderinger skal være obligatoriske og kreves bestått (men bidrar ikke til karkateren)Karakteren bestemmes av innleveringer som er individuelle eller levert i gruppe

Generelle teknikker for modellering, design og realisering av modulær programvare, med fokus på industrielle teknikker og anvendelser. Komponentbasert design, komponentbaserte arkitekturer og rammeverk, distribuerte komponentbaserte systemer. Modell-drevet utvikling av programvare, kode-generering og domenespesifikk språk. Testing, kontinuerlig integrasjon og forvaltning. 

Forelesninger og øvinger. Kurset kan bli forelest på engelsk dersom det tas av studenter uten norskkunnskaper. 

Kunnskaper: Studenten skal kunne generelle metoder for modellering, design og realisering av modulær programvare og modell-drevet utvikling av programvare, og hvordan disse brukes i ulike faser av utvikling og vedlikehold. Ferdigheter: Studenten skal ha praktiske ferdigheter i modellering, design og realisering modulær programvare, med moderne rammeverk og verktøy, også med modell-baserte teknikker. Generell kompetanse: Studenten skal kjenne til og kunne velge mellom ulike metoder og teknikker for utvikling av modulær programvare. 

Web/Lists(guid'8b698a2d-6ad0-4f7d-b3be-219cc1979f02')/Items(15462)/FieldValuesAsText

Avansert programvaredesign - TDT4250