-
Objectives
- Be able to describe the Java Persistence API and what value it brings over JDBC
- Be able to explain how JPA works with code examples
- Be able to explain what reflection means in Java
- Be able to write and explain code that uses reflection
-
Project
- Continue the work on the project, adding features to the structure you have built so far.
- Put some focus on the different types of automated tests: unit, integration and end-to-end tests
- A special project (and a webcast) is in preparation on the topic of testing. More information will be provided later.
-
The Question of the Week:
- Tests automatisés et taux de couverture de code à 100%: nirvana du développeur ou miroir aux alouettes?
-
Repos
- For the warm-up exercise: WHATELSE
-
For the homegrown framework: AMT-Framework
- Introduction to multi-tiered architectures
- Introduction to the Java EE / Jakarta EE platform and its evolution of the last 20 years
- The MVC design pattern
- Here is the repo for the first Java EE / Jakarta EE demo: https://github.com/SoftEng-HEIGVD/Teaching-HEIGVD-AMT-Discovery
- Here is the repo for the second demo (MVC): https://github.com/SoftEng-HEIGVD/Teaching-HEIGVD-AMT-MVC-simple-example. The README.md provides instructions for configuring IntelliJ and a local app server.
- Project: you have a first basic prototype of an application, which you can deploy in a Jakarta EE application server (e.g. Payara). The application allows the user to navigate between the (empty) pages of your future application. There is a working registration / login page, which is backed by in-memory datastore. You have learned how to do end-user acceptance testing with CodeceptJS.
- The notion of managed component
- Dependency injection
- Aspect Oriented Programming (AOP)
- Project: you have replaced the full Jakarta EE server with an embedded container (OpenLiberty), which you will use for the rest of project 1. You have an efficient development environment workflow, with IDE, Debugger and build pipeline (producing Docker images of your application). After registration and login, the user can ask questions. These features are protected with end-user acceptance tests.
- Addressing the "It works on my machine" syndrome with load testing
- Persistence with JDBC
- Project: you have moved from in-memory data stores to a RDMBs. You have performance / load tests for several use cases of your application. You have a Docker Compose topology for your application, with (at least) a database container.
- Reflection
- Persistence with JPA
- Project: users can add comments on questions and answers. You have unit / integration tests that validate the rules that govern these features (e.g. who has the right to add / edit / remove a comment?). Note: you don't have to use JPA for the project and can stick to JDBC.
- Both sessions reserved for project work
- Project: users can vote for questions and answers. You have unit / integration tests that validate the rules that govern these features (e.g. who has the right to vote on what? how many times?). You have end-user acceptance tests for all uses cases. You have load tests to validate the behavior of your application under concurrency. In particular, you have validated that it is not possible to loose votes under load.
- Monday: code freeze for project 1
- Wednesday: written test 1
- Friday: demonstration of project 1
- The design of REST APIs
- Document REST APIs with Swagger / Open APIs
- Introduction to Spring Boot
- Project: you have a first skeleton of the gamification engine, based on Spring Boot. You have specified the /events endpoint, used to report user activity with POST requests. You do NOT have to persist the events yet. You have JMeter scripts to exercise load on the endpoint. You have Cucumber BDD tests to specify and validate the behaviour of the endpoint.
- Webcasts to watch on Wednesday:
- Intro à la 2ème partie du semestre (link), 7:50, 2020
- Intro au 2ème projet (link): 30:38, 2020
- Intro aux APIs REST (link): 24:10, 2020
- Intro à Swagger (link): 26:53, 2020
- Intro à Spring Boot (link): 22:23, 2020
- Swagger avec Spring Boot: introduction (link): 10:26, (2016: do not try to replicate step-by-step)
- Swagger avec Spring Boot - étape 1 (link): 10:26 (2016)
- For the lab, we suggest that after everyone in the group has watched the webcasts to really understand the relationship between 1) the Swagger / OpenAPI spec, 2) the Spring Boot implementation of the spec and 3) the validation of the spec with automated tests written with CucumberJVM, then you split the work in two groups. One group starts by getting familiar with Spring Boot, Spring MVC and Spring Data (responsibility: implement a REST API, where controllers use JPA repositories to access a DB). One group starts by getting familiar with CucumberJVM and how to write BDD tests with this framework.
- For the lab, the easiest is to get started is to use the structure in this repo. Note that I am still working on it and will update master most likely on Friday morning. In the 2020 upgrade, we are moving from Swagger to Open API. We are upgrading libraries. We are also updating the code a little bit (e.g. to have an example of a date property).
- Webcasts to start watching on Friday:
- Swagger avec Spring Boot - étapes 2, 2bis, 3, 4 et conclusion (~90')
- Swagger et Cucumber (3 vidéos) (~30')
- Migration du projet de Netbeans à IntelliJ en 2017 (2 vidéos "micro-services") (~15')
- Gamification & event processing (6 vidéos) (~75')
- Introduction to Spring Boot
- Introduction to Spring Data
- Project: you have introduced the notion of "application" (your gamification engine is used to gamify several applications, so you need to process API calls in the context of a specific application). You have introduced the notion of "end-user". It is possible to register an application, get an API key. It is possible to send a stream of end-user events to the engine and thanks to the API key to make the correct associations. It is possible to get information about end-user via the REST API.
- Introduction to Lean Startup, by Jérôme Kehrli (CTO at NetGuardians) Article. From 9:30 to 10:30.
- Project: you have introduced a simple rule system. The user of your gamification engine (i.e. the developer of the gamified application) can specify how reputation points are awarded for different end-user events. You have implemented a number of queries to benefit from this information and made them available via the REST API (e.g. it is possible to get the reputation of one end-user, to get the top-10 end-users, to get the evolution of the reputation for one end-user over time).
- Both sessions reserved for project work
- Project: you have extended the rule system. The user of your gamification engine can specify how badges are awarded for different end-user events. You have extended your set of queries to make this information available via the REST API.
- DevOps, by Jérôme Kehrli (CTO at NetGuardians) Article. From 9:30 to 10:30.
- Project: you have a complete system. You have automated tests to validate end-to-end scenarios: several app developers can register their app with the gamification engine. They can create rules to setup their reputation system. The activity of end-users within the different applications is streamed to the gamification engine, which applies the configured rules. Application developers have access to the reputation of their users. You have load tests to validate that the system works correctly under concurrency.
- Monday: code freeze for project 2
- Wednesday: written test 2
- Friday: demonstration of project 2
- Recap and guidelines for the end of the semester
- Putting names to what we have put in practice: hexagonal architecture, clean architecture, onion architecture, domain driven design, the test pyramid
- Review of key concepts: separation of concerns, Aspect Oriented Programming, dependency injection, inversion of control, etc.
- Project: you have created a complete system, where your first project uses the your second project to gamify the experience of people who ask questions and provide answers. The application that you developed at the beginning of the semester makes calls to the REST API that you have developed in the second part of the semester.
- Wednesday: written test 3
- Project: your gamified application makes calls to your gamification engine to retrieve reputation information and present it in its user interface (e.g. the hall of fame is displayed on the home page, statistics are displayed on the profile page).
-
Wednesday: demonstration of project 3
-
Friday: demonstration of project 3
- The companion book (work in progress, you will have content for the first part of the semester).
- The AMT 2020 YouTube Playlist
- Frameworks and tools:
- Jakarta ee specs and application servers
- Spring ecosystem
- API design and documentation
- Testing