All lectures are recorded, except the first lecture and the guest lectures. You're expected to watch all lectures during the first two course weeks, and start the development immediately in the third week.

Live Lecture 1, Jan 16, 13-15, room 205, Course Introduction

This lecture covers course organization. It will be quite short, and doesn't cover any of the actual course content. All course content is covered by the prerecorded lectures.

Live Lecture 2, Jan 18, 13-15, sal B, Guest Lecture

Guest lecture by Daniel Hederstedt, a former TIDAB student who has been working with software development and architecture for over fifteen years.

Live Lecture 3, Jan 23, 13-15, given over Zoom, Guest Lecture on Git

Here's the presentation, Let’s talk Git - Basics & Workflows 2024 (with comments).pdf
Here's the recorded zoom lecture.

Prerecorded Lecture 1, Architecture Introduction

Introduction to Architecture

Content
00:00 Lecture Content
00:38 Definition of Architecture
08:20 Why Architecture Is Important
16:08 Definition of Non-Functional Requirements
20:21 Availability
20:46 Reliability
21:04 Response Time
21:17 Capacity
22:00 Scalability
27:16 Manageability
27:34 Configurability
27:52 Packaging
27:57 Standards
28:02 Use Certain Software or Hardware
28:17 Usability
29:12 Security, Introduction
29:53 Authentication
30:01 Authorization
30:10 Non-Repudiation
30:29 Integrity
30:35 Privacy
30:49 Logging
31:01 Design Goals, Introduction
32:43 Adaptability/Extensibility
32:57 Portability
33:16 Interoperability
33:28 Testability
34:46 Reusability

Here is the presentation used in the video above, architecture.pdf

Prerecorded Lecture 2, Architectural Decisions

Taking architectural decisions.

Content
00:00 Lecture Content and Lecture Notes
00:41 Introduction to Architectural Decisions
03:40 What to Consider When Taking Decisions
03:59 Documenting Decisions
05:19 Where to Start the Project

Here is the document about architectural decisions mentioned in the video above, taking-decisions.pdf

Prerecorded Lecture 3, REST Architecture

REST Architecture

Content
00:00 Lecture Content
00:28 The REST Principles
03:21 Addressable Resources
06:38 A Uniform, Constrained Interface
11:36 Representation-Oriented
13:25 Stateless Communication
14:03 HATEOAS
17:37 Server-Side Rendering, SSR
19:01 Client-Side Rendering, CSR
20:07 Advantages of SSR and CSR
22:27 The MVVM Pattern
27:12 Using AJAX for CSR.

Here is the presentation used in the video above, rest-csr.pdf.

Prerecorded Lecture 4, Modularization and Microservices

Modularization and Microservices

Content
00:00 Lecture Content
00:32 Software Layers
03:15 Monolith
13:14 Microlith
19:50 Communication Between Services
23:30 Event Sourcing
31:23 CQRS
34:46 Microservices
41:45 Function-as-a-Service, FaaS
46:44 Domain-Driven Design, DDD

Here is the document mentioned in the video above, modularization-micserv.pdf.

Prerecorded Lecture 5, A Server-Side Application

This lecture covers the programming skills required to start working with the project task. You will have to learn a lot more, on your own, to complete the project task. Note that there are three different versions of this lecture, you are only required to learn the content of (at most) one of them. Which one to watch depends on architectural decisions taken by your group, namely which frameworks to use, whether to use server-side rendering or client-side rendering, and whether to use a monolithic architecture or microservices.

You are not allowed to copy any code from any of the sample applications below, no matter how much you adapt it to your own application. You are, however, allowed to write code yourself that is very similar to the applications below.

Version 1, Server-Side Rendering with a Monolithic Architecture

This application is written in Java, with the Spring framework, and uses server-side rendering. Note however that there is no problem using Spring also for client-side rendering, rather it's even easier than using Spring for server-side rendering. This architecture is used in most code examples in other lectures.

Videos explaining this application can be found at https://canvas.kth.se/courses/16729/pages/application-server-lectures. As can be seen, they were originally recorded for ID1212, Network Programming. Therefore ignore everything in the videos that is mentioned about 'the course' or about assignments, since that isn't about this course, IV1201.

The page with the videos, see the link above, also has a link to a GitHub repository where you can find that application. You might however instead want to look at this application, https://github.com/KTH-IV1201/bank.git, which is an extended version of the same program, including for example tests.

Version 2, Client-Side Rendering with a Monolithic Architecture

This application is written in JavaScript, with the Express framework, and uses client-side rendering. Note however that there is no problem using Express also for server-side rendering. There are some code examples in other lectures using this architecture.

A Few Words About Cross-Origin Resource Sharing (CORS)

When using client-side rendering, it's best practice to split the application into two separate applications, one for the frontend and one for the backend, to be able to handle client-side code and server-side code independently. This means JavaScript code in the browser, which is loaded from the frontend server, will make calls to the backend server. Such a cross-origin request, to another server than the one from which the code was loaded, is for security reasons disallowed by the same-origin policy used by all browsers. To make this work, it's necessary to enable cross-origin resource sharing, CORS.

Here's a sample application, illustrating CORS on an application deployed to Heroku, frontend backend.

You can read more about CORS for example on the CORS page at MDN.

The Client-Side Rendering Application

The application can be found at https://github.com/KTH-IV1201/chat.git

Here is a pdf with a presentation explaining the application, node-express-sequelize.pdf.

Here are videos explaining the application.

A REST Application, Part 1

Content
00:00 How This Lecture Fits in the Course
08:48 Lecture Content
10:45 Executing the Sample Application
16:11 The Express.js framework
27:52 Layers in the Sample Application
30:51 Startup Code, Part 1
32:21 Configuration Parameters
36:01 Startup Code, Part 2
55:01 Error Handling

A REST Application, Part 2

Content
00:00 Database Handling
15:47 Handling an HTTP call, createMsg
16:56 Handling the HTTP call in the view
21:57 Authentication and Authorization
27:04 Reading User Data From Database
36:09 Handling the HTTP call in the controller
36:40 Handling the HTTP call in the DAO
37:53 Sending HTTP Response

Version 3, Client-Side Rendering with a Microservices Architecture

This application is written in JavaScript, with the Nest framework, and uses client-side rendering. It is quite different from the applications above in the sense that it has a microservices architecture. In one way, using this solution you get quite a lot for free since this sample application is in fact a recruitment application, very similar to what you shall develop in the project. On the other hand, this architecture is more complicated than the ones above. Also, there is no lecture or tutorial explaining this solution.

This application can be found here, https://github.com/philipromin/Recruitment. Thanks to Philip Romin, who developed this application for his bachelor thesis.

Prerecorded Lecture 6, Development Tools

Tools, Part 1: Build, Test and CI/CD

Content
00:00 Lecture Content
06:25 Maven
29:14 npm
43:16 In-Container vs Mocked Tests
49:40 Spring MVC Test Framework
01:00:59 Jest
01:13:47 CI/CD
01:29:42 Containerization, Docker

Tools, Part 2: Static Analyzers, Dependency Analyzers and Test Coverage

Content
00:00 Static Analysis
06:25 Dependency Analysis
10:31 Test Coverage Analysis, Only usage with Java is included in the video, but the sample JavaScript application also includes test coverage analysis, as is explained on page 12 in the presentation (tools-cli-js.pdf).

This presentation, tools-cli-java.pdf, gives examples of tools for Java development. It refers to the sample application at https://github.com/KTH-IV1201/bank.git.
This presentation, tools-cli-js.pdf, gives examples of tools for JavaScript development. It refers to the sample application at https://github.com/KTH-IV1201/chat.git.

Prerecorded Lecture 7, Architecture, Design and Non-Functional Requirements on the View

The quality of this recording is unfortunately quite low. The sound is far from perfect, the video is blurred the first seconds of each part, and the zoom chat window covers part of the presentation.

Requirements on the presentation layer, part 1

Content
00:00 Lecture Content
01:25 Typical Layers in a Web App
04:32 The Client Layer
14:35 Caching
23:36 Navigation
27:26 Validation
37:06 Flow Control
40:22 Composite Views

Requirements on the presentation layer, part 2

Content
00:00 Internationalization
08:20 Session Management
13:03 Error Handling
23:45 Logging
26:46 Authentication and Authorization
28:43 Authentication in a REST API
40:15 JSON Web Tokens, JWT

Here are the presentations used in the videos.

Requirements on the presentation layer, requirements-presentation.pdf.
Security aspects of a web application, security.pdf,

Prerecorded Lecture 8, Architecture, Design and Non-Functional Requirements on the Model

Requirements on the controller and model layers

Content
00:00 Lecture Content
01:23 Statefullness
07:04 Synchronization With the Database
14:00 Error Handling
21:36 Internationalization
22:28 Security
22:51 The DTO Pattern

Here is the presentation used in the video, Requirements on the model layer, requirements-model.pdf.

Prerecorded Lecture 9, Transactions

There's an introduction to transactions at https://canvas.kth.se/courses/27118/pages/transactions. As can be seen, it was originally recorded for IV1351, Data Storage Paradigms. Therefore ignore everything mentioned about 'the course' or about assignments, since that isn't about this course.

Watch the transaction introduction lecture above before watching this lecture on Transaction handling in a web application

Content
00:00 Where to find an introduction to transactions
00:58 Start and stop transactions in the controller
04:48 Every operation needs a transaction
12:00 Always use declarative transactions
16:03 Never lock anything manually
19:55 State that's not handled by the transaction manager
27:57 Summary of transaction handling in a web app
30:08 Transactions in Spring
37:10 Transaction in Sequelize
43:44 Non-Transactional Resources
45:51 Use cases spanning more than one transaction

Here is the presentation used in the video, transactions.pdf.

Prerecorded Lecture 10, A Few Words About Document Databases

There are no requirements on databases or on the integration layer in the project, except that they shall exist and follow general guidelines applying to the entire application. Still, since each year one or a few groups are interested in using a document database instead of a relational database, there is here an introduction to document databases. There is also a comparison of relational and document databases, with the goal to show that database type shall be chosen based on application, not based on programming language or framework stack. This material was originally created for another course, therefore ignore anything mentioned about the course.

This document explains major differences between document and relational databases, and also covers strengths and weaknesses of the two, doc-db.pdf. There is no video lecture covering the content of this document, instead care has been taken to cover everything in writing.

This document, a_comparison_of_backend_and_DB_in_regards_to_response_time.pdf, is an evaluation of response times for both web servers and DBMSs and might be of interest when choosing framework, server and DBMS. It's also of interest because it was written by a student of this course, as a solution to the task Other Non-Functional Requirements in the list of assignments in the document tasks-affecting-grade.pdf, and thus is an example of how this task can be answered.

An example application using a document database can be found at https://github.com/KTH-IV1351/doc-db-intro.git, and is explained in the video below.

Accessing a Document Database Programmatically