Python is a programming language that is relatively easy to use for beginners, but commonly used by experts as well. It is a general purpose language, meaning it can be used to create many types of computer programs. It is often used for quickly automating tasks, data analysis, artificial intelligence and for creating web applications. In this module, we'll learn the basics of imperative programming using Python.

Learning goals:

• Declare and assignment variables.
• Output text and read user input.
• Branch using if, elif and else.
• Use loops.
• Use comments and whitespace to improve readability.
• Define and use functions that take arguments and return a value.
• Give variables and functions concise but descriptive names.
• Convert other types to string, concatenate strings and take substrings.
• Create, search, modify and iterate lists.
• Find and solve bugs in a program using a debugger.
• Use dictionaries to model relations.
• Read and write files.
• Use modules to split a program into logical parts.
• Gracefully handle errors by throwing and catching exceptions.

At its core, the world wide web consists of a collection of documents that link to each other. The documents are written using HTML and styled using CSS. Both are languages intended to be understood by computers, but are not programming languages. We will learn these languages to be able to create decent-looking web pages. Later on, we'll build on this knowledge to create web applications.

Learning goals:

• Write valid and semantic HTML.
• Apply styling to a site using plain CSS.
• Apply basic graphical design principles for fonts, colors, spacing and alignment.
• Create web sites that look and work well on any screen size.
• Use icons and fonts.
• Construct HTML forms to collect user input.

Applications usually work on (large amounts of) information. Such information is often stored in a database that is controlled by a database management system. The system we'll be working with is PostgreSQL. Like other well-known database systems (such as Oracle, MySQL and Microsoft SQL Server) one can interact with it using the SQL computer language in order to store and retrieve data. We will be learning how to represent real-world objects as an SQL database, and how to efficiently generate all kinds of useful reports from this data.

Learning goals:

• Use SQL select queries to read, search, write, update and delete records.
• Write SQL queries involving joins.
• Describe real-world objects using Entity Relationship Diagrams.
• Use GROUP BY and aggregate functions to calculate statistics.
• Use subqueries.
• Create normalized database tables based on an Entity Relationship Diagram.
• Use indexes to enhance query performance.
• Use foreign keys to guarantee data consistency.
• Use views to simplify complicated database queries.

Object-Oriented Programming (OOP) is a way of programming using objects that 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.
• Using abstract classes and methods.
• 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.
• Understand and implement event-based programming.

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.

Develop single page, offline and progressive web applications that look and feel similar to native. Automate executable specifications to drive development and validate that your implementation meets acceptance criteria.

Learning goals:

• Program in JavaScript and TypeScript.
• Manipulate the browser DOM to add interactivity to web sites.w
• Create single-page applications.
• Create applications using a frontend reactive component framework.
• Create web-based apps that look and feel similar to native apps.
• Create progressive web apps that behave like native apps.
• Use a frontend component library.
• Persist data locally in progressive web apps.
• Create single page applications featuring useful URLs.
• Create automated end-to-end tests for progressive web apps.
• Create hybrid apps, accessing device native functionality using web tech.

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:

• Understand the basics of the Internet Protocol.
• 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.

Create and test a networked application.

Learning goals:

• Program TCP and UDP clients and servers.
• Implement a simple protocol based on a specification.
• Use the Node.js ecosystem, including packages and build tools.
• Build tidy REST APIs using Node.js and express.js.
• Securing networked applications.
• Create apps based on realtime server-to-client communication.
• Create API tests.
• Build fullstack application that use REST apis and realtime communication.
• Understanding Cross-origin resource sharing (CORS) in networked applications.

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 our very own LMS Open Source project! This skill will come in handy when doing your internships.

Learning goals:

• Analyze a large and complex pre-existing code base.
• Contribute a new feature to a pre-existing code base, fitting in with existing practices.
• Collaborate on an online platform to contribute code.
• Perform a thorough but considerate code review.
• Improve your work based on a code review.
• Present your work in a public presentation.

Once you have 55 ECTS, you can start planning your internships.

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 10 full-time weeks.

Learning goals:

• Implement software.
• Proficiently use common technologies.
• Quickly and independently learn to use new techniques.
• Use automated software testing and deployment.
• Collaborate within a development team.

Sometimes programs have tight constraints on resource usage, for example games trying to achieve maximum performance, and programs meant to run on tiny embedded computers. In this course, we will dive into meeting these constraints with a low-level program language; Rust!

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 multi-threaded programs.
• 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.

Learning goals:

• Write simple programs in an assembler language.
• Interpret or compile computer languages.
• Create parsers for domain specific languages.
• Write regular expressions to match complex patterns in strings.

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.

Like the first internship, but at a (hopefully very) different organization and bringing more experience to the table. This internship (including a reflection on the differences with your earlier internship) counts for half your graduation grade.

Learning goals:

• Implement software.
• Proficiently use common technologies.
• Quickly and independently learn to use new techniques.
• Use automated software testing and deployment.
• Collaborate within a development team.

Learning goals:

• Create functional designs.
• Create technical designs.
• Apply insight to solve 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 multi-threaded 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.

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 multi-threaded programs.
• Write simple programs in an assembler language.

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.
• Using abstract classes and methods.
• 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.

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.

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.

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.
• Build tidy REST APIs using Node.js and express.js.
• Manipulate the browser DOM to add interactivity to web sites.w
• Use Svelte to implement a web app.
• Create (progressive) web apps that install as native apps and work offline.
• Create API tests.
• Create automated end-to-end tests for progressive web apps.

Learning goals:

• Analyze a large and complex pre-existing code base.
• Contribute a new feature to a pre-existing code base, fitting in with existing practices.
• Collaborate on an online platform to contribute code.
• Present your work in a public presentation.

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 10 full-time weeks.

Like the first internship, but at a (hopefully very) different organization and bringing more experience to the table.

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.
• Use automated software testing and deployment.
• Collaborate within a development team.