Object-Oriented Programming (OOP) is a way of programming using objects than contain data as well as code. This can make it easier to organize larger computer programs. We'll learn how to apply the various OOP concepts in Python.

Learning goals:

• Create and use simple classes with a constructor, methods and instance variables.
• Create inheritance hierarchies to model real-world objects.
• Use static methods and class variables.
• Utilize third-party libraries.
• Create well-described interfaces that hide underlying details.
• Decompose a larger program into logical parts.
• Effectively use a documentation generator to document a public interface.
• Use refactoring to improve code quality.
• Implement design based on class diagrams.

In period 1.1 we learned how to create a static (non-interactive) web page. In this module, we'll learn how to add interactivity by adding a dynamic backend consisting of Python, the Flask framework and an SQL database. We'll also learn about the use of a test plan, to make sure your dynamic web site does what it's supposed to do.

Learning goals:

• Create web apps using Flask and Jinja2.
• Create Python programs that fetch and modify data in a database.
• Use an Object Relation Mapper.
• Implement user authentication and authorization following best practices.
• Recognize and protect against common security bugs in web apps.
• Create validated web forms.

Up until this point in the study program, you have always been provided with a pretty clear description of what the end result of an assignment should actually do. In this module, you'll learn techniques to create a functional design yourself, based on the wishes of a client. To keep your designs very practical, our focus will be on the User Experience (UX) part of the design. You will design user interactions using wireframes and descriptions of interactivity.

Learning goals:

• Effectively interview stakeholders with regard to requirements.
• Translate business requirements to a functional design.
• Conduct user studies.
• Draw wireframes to rapidly describe user interfaces.
• Describe real-world objects using Entity Relationship Diagrams.
• Create UX designs for different device types.

An algorithm is a list of rules to follow in order to solve a problem. A data structure is a particular way of organizing data so that it can be used effectively. We'll be learning to select suitable algorithms and data structures, to reason about their efficiencies and to implement them. We'll approach this by studying a few of the common ones. Along the way, we'll also learn how to create a properly documented and unit-tested self-contained module out of them.

Learning goals:

• Create unit tests to validate whether a module works as intended.
• Implement algorithms expressed in pseudo-code.
• Select algorithms based on algorithmic time/space complexity.
• Knows how and when to use arrays (lists), maps (dictionaries), linked lists and trees.
• Effectively use recursive functions.
• Use graphs to store and process data.
• Understand, implement and use sorted data structures such as trees and heaps.
• Use backtracking to find optimal solutions to a class of problems.

In this module, we'll learn a second programming language: Java. We'll use it to create apps for the Android platform.

Learning goals:

• Program in Java.
• Write multithreaded programs.
• Create and control Views and work with Android APIs.
• Use Android Studio to design ConstraintLayouts suitable for any screen size.
• Create and spawn Android activities, carefully managing their lifecycles.
• Create lists with and without a custom view on Android.
• Exchange data with an HTTP server on Android.
• Use Android Room to store and retrieve local data.

Software is usually developed in teams. This can be a lot of fun, but it also brings some challenges... This module provides you with some theory about working as part of a professional development team, as part of a larger company. You'll also practice your presentation skills.

Learning goals:

• Know what it means to be an employee in terms of expectations, procedures, the law, contracts and salary.
• Employ personal time management techniques in order to be happier, healthier and more effective.
• Reflect on the use of various software project management models and their differences.
• Understand the function of and interaction between employee roles within software companies.
• Create simple software in a small, informally managed team.

How does a computer work? How would you program one without the use of a high-level programming language like Python? Let's find out! And while we're at it, we'll as learn how to interface with hardware components! Although only relatively few software developers do this type of low-level work on a regular basis, knowing about what "lies underneath" does make every developer more effective.

Learning goals:

• Work with binary data, bits and bytes.
• Explain the basic operation of a CPU, and its relation to memory and I/O.
• Understand how the call stack works.
• Use data types, variables, control flow, functions and terminal I/O in Rust.
• Manually manage heap memory for a simple program.
• Use and define traits and generics in Rust.
• Use polymorphism in Rust.
• Understand and use pointers.
• Optimize applications for performance.
• Work with low-level graphics primitives.
• Write simple programs in an assembler language.

Many modern web applications are 'single-page', meaning they don't have the concept of pages that you navigate between. Examples include Google Maps, WhatsApp Web and the Spotify web-client. Instead of having the server create HTML pages, the HTML is created from within the browser itself using the JavaScript programming language. The client-side JavaScript program usually communicates with one or more servers through an application programmers interface (API) to exchange data. Let's learn how to build such web apps! And yes, that implies learning JavaScript too. We'll also learn how to perform automated tests on the user interfaces that you've created.

Learning goals:

• Program in JavaScript.
• Use the Node.js ecosystem, including packages and build tools.
• Create single-page applications in JavaScript.
• Build tidy REST APIs using Node.js and express.js.
• Manipulate the browser DOM to add interactivity to web sites.
• Use Svelte to implement a web app.
• Create (progressive) web apps that install as native apps and work offline.
• Create API tests using Cypress.
• Create end-to-end tests using Cypress.

When working for a company, software developers are often asked to improve upon pre-existing software projects. Let's learn and practice how to do that, by adding to an Open Source project of your choice! This skill will come in handy when doing your internships.

Learning goals:

• Analyze a large and complex pre-existing code base.
• Implement new features on top of a pre-existing code base.
• Adhere to a code base's coding standards and contribute changes upstream.
• Effectively explain things in a presentation.

Many computer programs need to communicate complex data with users or with other computer programs. Protocols and computer languages exist to make this possible. We'll learn about some common protocols (such as those used by the internet) and how to work with them, about encryption, and about how to create a parser to have your program 'understand' a computer language.

Learning goals:

• Understand the basics of the Internet Protocol.
• Program TCP and UDP clients and servers.
• Asynchronous programming.
• Implement a simple protocol based on a specification.
• Effectively apply (a)symmetric encryption.
• Write regular expressions to match complex patterns in strings.
• Create parsers for domain specific languages.
• Interpret or compile computer languages.

In many working environments, software developers are not only responsible for solving problems by creating great software, but for testing and deploying it as well. In this module we'll learn about some of the tools and techniques commonly used to do this.

Learning goals:

• Perform basic Linux system administration.
• Automate tasks using Linux shell scripting.
• Encapsulate applications using Docker and Docker Compose.
• Deploy applications to a public cloud infrastructure.
• Declare and deploy a simple infrastructure from code.
• Perform git commits, merges and rebases from the command line.
• Use a web-based DevOps platform (GitLab) for issue management and merge requests.
• Write scripts to automatically build, test and deploy apps using GitLab.

A technical design gives a high-level overview of how a functional design will be implemented. Important technical decisions should be made, hopefully based on more than just gut feeling. The program should be split into logical parts and it should be clear how these parts communicate. All of this should be documented in a way that makes it easy for other software developers to understand what is going on.

Learning goals:

• Recognize and apply common design patterns.
• Design class diagrams for non-trivial systems.
• Create high-level overviews of software architectures.
• Create graphical software models using PlantUML.
• Make methodical decisions.
• Decompose a larger program into logical parts.
• Design scalable systems.
• Design reliable systems.
• Design secure systems.

During the first year, you have learned to create relatively small applications by yourself. The internships are meant to teach how to cooperatively work on larger applications. It will be on the job learning, as a trainee within a professional development team. Each internship lasts for 12 weeks, 4 days per week. No credits are awarded for completing an internship. Instead, you should showcase results from your internships as part of your graduation portfolio.

A programming project of your own choosing. Create something awesome! No credits are awarded for completing the project. Instead, you should showcase it as part of your graduation portfolio.

Like the first internship, only at another organization. The goal is to get to experience some of the very different ways in which software development processes are managed.

Another awesome technical project of your own design! If you like, you can team up with a classmate or two.

Learning goals:

• Create functional designs.
• Create technical designs.
• Implement software.
• Apply insight to solve problems.
• Proficiently use common technologies.
• Quickly and independently learn to use new techniques.
• Automate software testing and deployment.
• Collaborate within a development team.

Many modern web applications are 'single-page', meaning they don't have the concept of pages that you navigate between. Examples include Google Maps, WhatsApp Web and the Spotify web-client. Instead of having the server create HTML pages, the HTML is created from within the browser itself using the JavaScript programming language. Using component libraries and "hybrid mobile frameworks" it's possible to create smartphone as that look and feel very similar to native apps, and can have the same capabilities. Let's learn how to build such apps!

Learning goals:

• Program in JavaScript.
• Use the Node.js ecosystem, including packages and build tools.
• Create single-page applications in JavaScript.
• Build tidy REST APIs using Node.js and express.js.
• Manipulate the browser DOM to add interactivity to web sites.
• Use Svelte to implement a web app.
• Create (progressive) web apps that install as native apps and work offline.
• Create API tests using Cypress.
• Create end-to-end tests using Cypress.

Sometime programs have tight constraints on resource usage, for example games trying to achieve maximum performance, and programs meant to run on tiny embedded computers.

Learning goals:

• Work with binary data, bits and bytes.
• Explain the basic operation of a CPU, and its relation to memory and I/O.
• Understand how the call stack works.
• Use data types, variables, control flow, functions and terminal I/O in Rust.
• Manually manage heap memory for a simple program.
• Use and define traits and generics in Rust.
• Use polymorphism in Rust.
• Understand and use pointers.
• Optimize applications for performance.
• Work with low-level graphics primitives.
• Write simple programs in an assembler language.

How does a computer work? How would you program one without the use of a high-level programming language like Python? Let's find out! Next, we'll implement our own programming language parsers and compiler on top of that! Although only relatively few software developers do this type of low-level work on a regular basis, knowing about what "lies underneath" does make every developer more effective.

Object-Oriented Programming (OOP) is a way of programming using objects than contain data as well as code. This can make it easier to organize larger computer programs. We'll learn how to apply the various OOP concepts in the C# language.

Learning goals:

• Create and use simple classes with a constructor, methods and instance variables.
• Create inheritance hierarchies to model real-world objects.
• Use static methods and class variables.
• Utilize third-party libraries.
• Create well-described interfaces that hide underlying details.
• Decompose a larger program into logical parts.
• Effectively use a documentation generator to document a public interface.
• Use refactoring to improve code quality.
• Implement design based on class diagrams.