No enterprise can afford to waste resources, be it time, money, or energy. Currently, optimization methods such as metaheuristics that can be used to reduce operational costs and resource consumption are a booming field. This is caused by several factors, such as the increased control that IT can exert over manufacturing due to concepts such as cyber-physical systems or the internet of things, or the rise of available computing power (e.g., due to cloud computing) as well as the availability of more (big) data. With all of these tools, we aim to automate decisions in management, planning, scheduling, and logistics. But, of course, automated decisions should be intelligent. And metaheuristics offer exactly this: The capability to make good decisions automatically and quickly.

This course, Metaheuristics for Smart Manufacturing [智能制造的元启发式算法], is designed to fit in either one or two compact slots of maybe four hours. We first try to get a basic understanding what an optimization problem is. We then pick a prominent example problem from the field of smart manufacturing and try to tackle it. We begin by developing a very simple and stupid algorithm and then step-by-step move on to better approaches.

Goals: We will

  1. learn about the basic principles of metaheuristic optimization,
  2. learn about the most prominent families of algorithms in the field,
  3. test these algorithms on a problem from smart manufacturing and investigate their strengths and weaknesses, and thus
  4. become able to quickly design optimization software prototypes for specific applications.

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 a superlative (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 it may not always be possible within feasible time. More scientifically speaking: The worst-case runtime of the best known exact algorithms for hard problems grows exponentially with the number of decision variables, which can easily lead to billions of years for larger problem 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 (see also 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 (e.g., run too long) and know how to find good solutions for them within feasible time. This lecture also improves the student’s ability to write programs and shows them that formally specified algorithms often can be translated to code in an easy, non-scary way.

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

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

This course [Java 面向对象程序设计] 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