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.
Goals: We will
- learn about the basic principles of metaheuristic optimization,
- learn about several of the most prominent families of algorithms in the field,
- implement many of these algorithms, and thus
- 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:
- the world wide web and web-based applications,
- distributed enterprise applications in a service-oriented architecture,
- cloud computing,
- 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, travis.ci, and GitHub.
Goals: Learn how distributed systems work, from bottom to top, e.g., by understanding
- how communication in a network works at the lowest level,
- how we can use these communication primitives via the socket interface,
- how computations can be parallelized by using multiple threads,
- how protocols such as HTTP work,
- how (multi-thread) servers such as web servers work,
- how to use servlets to build servers generating dynamic contents,
- how to build dynamic websites based on JSPs (which are special servlets),
- how enterprise applications are structured into frontends and application servers,
- how application servers can provide their functionality via RMI, web services, or JSON RPC, and
- how large tasks using big data can be performed in a distributed fashion using MapReduce.
Teacher: Prof. Dr. Thomas Weise
In this class, the fundamentals of microcontroller system hardware and firmware design will be explored. Issues such as hardware/firmware partitioning, glue logic, development tools, firmware architecture, firmware design, and firmware debugging will be discussed. The Intel 8051, a very popular microcontroller, will be studied. The architecture and instruction set of the microcontroller will be discussed, and a basic microcontroller platform will be used for students to learn how to design realistic and practical microcontroller systems and applications.
Students will obtain practical experience with the design process and both learn and reinforce their knowledge of specific technical topics covered in the lecture and applied in the lab.
Microcontroller systems are involved in almost every facet of modern life. Cell phones, touch screens, pagers, washing machines, microwave ovens, televisions, video game consoles, GPS devices, network routers, fax machines, cameras, music synthesizers, planes, spacecraft, boats, and cars all contain microcontrollers. Modern cars often contain many microprocessors, performing such tasks as antilock braking, climate control, engine control, audio system control, airbag deployment, etc. Logic analyzers and digital storage oscilloscopes utilize processors to support real-time operation. Even PCs, which are designed around powerful CPUs such as the Intel Pentium i7, contain additional microcontroller systems. Storage devices such as hard disks, solid state disks, CD-RW-, DVD+RW-, and Blu-ray drivers as well as external peripherals such as printers, scanners, and other SCSI, USB, or IEEE 1394 devices all contain microcontrollers. Furthermore, microcontrollers are indispensable tools for automation and intelligent manufacturing as well as robot control.
The tremendous number of applications for microcontrollers has given rise to a high demand for engineers with experience in designing and implementing microcontroller systems. This course will give students hands-on experience and opportunities for experimentation in this exciting field.
Prerequisites: Knowledge of microprocessor architecture and assembly language, microprocessor peripherals, digital design, and the C programming language.
Teacher: Dr. Zhen Liu
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.
- Attain basic programming skills, including
- Learn how to use the most important tools for productive software development, including
Teacher: Prof. Dr. Thomas Weise