This course enables a student with little previous knowledge about programming to write programs in a productive environment using the Java programming language. This involves developing two sets of skills: A programmer must understand the programming language itself, its underlying paradigms, its utilities, syntax, and how to translate the specification of a task into program code. Since software is often developed in a team, a programmer also needs to know the basic tools predominantly used in the ecosystem centered around the programming language. She must not only know how to structure her code for maximum reuse and minimum maintenance requirements, but also how to use and create libraries, as well as how debug and document code. Our course tries to address both requirements in an integrated fashion.

This course has been designed by Prof. Weise from scratch. It does not just try to teach programming in a practical way, using many fully functional examples. It also introduces the tools that are needed to become an effective software engineer (and which usually are entirely ignored in academic courses) at didactically suitable points.

Prerequisites: None


  1. Attain basic programming skills, including
    1. assignments, expressions, conditionals, loops, functions
    2. object-oriented programming, class hierarchies, inheritance, interfaces, encapsulation
    3. exception handling
    4. basic Java utilities such as collections and streams
  2. Learn how to use the most important tools for productive software development, including
    1. using an IDE (Eclipse)
    2. using a debugger
    3. documentation with Javadoc
    4. creating and using libraries (JAR)
    5. unit testing using JUnit
    6. build processes using Maven

Teacher: Prof. Dr. Thomas Weise

Distributed systems surround us everywhere today. Their most prominent example is the internet hosting the world wide web. The computing environment in enterprise computing systems is often distributed too, interconnecting different services from human resources, financial departments, to asset management systems. Many applications are even hosted in the cloud. Finally, large-scale engineering and scientific computing today rely heavily on clusters in order to parallelize their workload. These topics are discussed in this distributed computing lecture. In this course, we explore different aspects of distributed computing.

The concept of this course is that we want to understand how the web and distributed enterprise application environments work. We want to do that by starting to explore how to communicate over a network at the lowest level of abstraction (normally) available to programmers, the socket API. From there, we work our way up step-by-step higher levels of abstraction, i.e., simpler and more powerful API stacking on top of each other (and ultimately grounded in sockets). This way, we will gain a solid understanding how distributed applications and the web work. We will be able to look at a website and immediately have a rough understanding of how it may work, down to the nuts and bolts. For each level of abstraction that we explore, we therefore always learn example technologies. The goal is to get a comprehensive understanding of the following topics:

  1. the world wide web and web-based applications,
  2. distributed enterprise applications in a service-oriented architecture,
  3. cloud computing,
  4. large-scale distributed computing.

For this purpose, we start by briefly discussing the basic communication infrastructure of the internet and the protocol layers (Ethernet, IP, TCP and UDP). We then introduce the sockets API, i.e., the basic API provided by operating systems to access TCP and UDP. When discussing the socket API, we also explore data and text encoding as well as the construction of parallel servers using threads and thread pools. We learn that web browsers and web servers communicate via HTTP is a text-based protocol transmitted via TCP/IP. We implement a very primitive web server by using our knowledge of sockets and HTTP. We then learn that Java Servlets are a more convenient way to implement HTTP servers. We find that servlet containers, i.e., the server software executing servlets, work almost exactly as our parallel web servers, by using thread pools.

We then learn JavaServer Pages (JSPs) as a technology to build dynamic web pages which builds on Java Servlets: our JSPs are compiled to servlets by a servlet container. Distributed enterprise computing today is largely based on web services, which use the XML-based SOAP standard, usually transmitting information via HTTP. We therefore first learn about XML and how to process XML documents in Java. We then implement and use our own web services with axis2. We learn that axis2 can be deployed as servlet, i.e., uses the same infrastructure we already learned.

We move on to learn about how cloud computing allows us to outsource our IT infrastructure (and the associated security risks). We will see how cloud computing frameworks such as the Google App Engine allow us to deploy Java Servlets to a cloud provider’s data center. This closes the circle of enterprise and web application development in this course: We learned all layers of abstraction, from the very basic protocols such as IP, TCP, and UDP, over the socket interface with which we can access them, text encoding, parallelism, to HTTP, the most important protocol in the Web, to Java Servlets which can access it, servlet containers running servlets (using TCP sockets, text encoding, and parallelism), over JSPs, web services, to cloud computing.

For each aspect, we explore several examples (and hands-on homework) using state-of-the-art technologies. As added “bonus”, we use modern build environments and tools such as git, Maven,, and GitHub.

Prerequisites: Java Programming (e.g., learned in our course Object-Oriented Programming with Java)

Goals: Learn how distributed systems work, from bottom to top, e.g., by understanding

  1. how communication in a network works at the lowest level,
  2. how we can use these communication primitives via the socket interface,
  3. how computations can be parallelized by using multiple threads,
  4. how protocols such as HTTP work,
  5. how (multi-thread) servers such as web servers work,
  6. how to use servlets to build servers generating dynamic contents,
  7. how to build dynamic websites based on JSPs (which are special servlets),
  8. how enterprise applications are structured into frontends and application servers,
  9. how application servers can provide their functionality via RMI, web services, or JSON RPC, and
  10. how large tasks using big data can be performed in a distributed fashion using MapReduce.

Teacher: Prof. Dr. Thomas Weise

Whenever we face a situation with multiple choices, we want to pick the best one. This is true for our daily life, but also for many scenarios in industry, management, planning, design, engineering, medical services and logistics. Actually, any question for superlatives (fastest, cheapest, strongest, most valuable, ...) is an optimization problem. In this course, we want to discuss the metaheuristic way of solving these problems.

Metaheuristics are an approach to solve hard problems. A problem is hard if finding the best possible solution for them may always not be possible within feasible time. More scientifically speaking: The runtime of the best known exact algorithms for hard problems grows exponentially with the number of decision variables in the worst case, which can easily lead to billions of years for larger instances.

So how can we solve such problems?

Well, finding one solution to a problem is almost always very easy and can be done extremely fast, finding the best possible solution is what takes very long, as we discuss here here. Optimization algorithms bridge this gap: They trade in solution quality for runtime, by finding very good (but not necessarily optimal) solutions within feasible time. We explore the state-of-the-art optimization methods ranging from local searches over evolutionary computation methods and memetic algorithms to estimation of distribution algorithms. We learn that these algorithms are actually easy to understand and to program: many of the algorithms are implemented live by the teacher in the lecture in Java after describing their basic principle.

After the course, the students will have a solid practical understanding of optimization. They will be able to recognize problems where “traditional” techniques will fail (run too long) and know how to find good solutions for them within feasible time. This lecture also improves the student’s ability to program and show them that formally specified algorithms often can be translated to code in an easy, non-scary way.

It should be noted that optimization algorithms are one of the key enabling technologies for currently trending concepts such as Made in China 2025 [中国制造2025] and Industry 4.0., as discussed here.

Prerequisites: Java Programming (e.g., learned in our course Object-Oriented Programming with Java)

Goals: We will

  1. learn about the basic principles of metaheuristic optimization,
  2. learn about  several of the most prominent families of algorithms in the field,
  3. implement many of these algorithms, and thus
  4. become able to quickly design optimization software prototypes for specific applications.

Teacher: Prof. Dr. Thomas Weise