In the second semester I had a module about assembly programming. The model for the assembly programming was the Intel 8051 microcontroller. Some topics were basics of the CPU clock and cycles, interrupts and some trivials when programming in assembly like jumps. We had to understand how the adressing works. We noticed that this is sometimes difficult to think about when we programmed our own tasks. For example not overwriting the register of the accu machine or let a code snippet run a defined time (for example for a frequency signal). But anyway I like those challenges, although it was difficult. Also we lerned that this assebly only works for the 8051. Other CPUs have other registers, bus width or just an other machine architecture. When understanding this, it was clear for me, that this code can not be ported for an other machine in easy way like for an application written in C. This is were my respect comes from making a program for a specific machine. But also it is was a clear fact that this way I can make a more specefic program for an machine. Over all I'd like this kind of programming and the module itself.

Both pictures show the last task, that was to show the eyes of a die on a dot- matrix- display. This was a very difficult task to be able to display column-wise and short timed a column. Fist show a column, switch all values and port, then display the nex column, until all are shown. All this on a frequency that we had to calculate and must keep it as condition to repeat anything. After done this expand all to display any side of a die. It was a nice task, but it was clear how many things are easier using high-level languages.

In the Module "Systems Programming" at the third semester we had anything about system adminstration - and of corse since the module is mostly about Linux - also systemcalls as an interface to the kernel-space were topics. We got introduced into writing managing scripts ([ba]sh) to make system administration easier. Of corse in such a style: using variables, reading of values, loops and at least process chaining and other useful tools on Linux command line. Also from beginning we got introduced in the "make" tool and got requested to use "makefiles" when doing our prictical tasks. These contents were already helpful in the administration of my private systems.
Further it was the systemcall system of Linux explained and used in some programs. Also it was talked about makro programming in C.
In the module "real time systems" the topic of real time programming in software was only a generally view onto the topic. The most explained topic was how the process modell of the most operating systems works and talked about some scheduling strategies. Also interprocess comunication with the signal system was topic. Among others here we talked about real time. At the end we had the topic of threads and how we can use these for programming in C using pthread. Further we talked about data safety, mutexes and deadlocks.

In the pictures you see a task for shell scripts, a modell simulation for management of processes in linux and a program that calculates the quersum of numbers using the help of pthreads.

In this module we lerned something about iOS App development. This module is part of the optional modules. Therefore is the developmet on mobile in a mode made for optional modules. Sadly there is no other module in the studying which handles the development for mobile. At this module we had parts with lerning something about the Swift programming language and something about the concepts on the app development for the iOS plattform. Of course at the beginning starting with the "Model, View, Controller" concept. In addition we programmed some small apps to practise the lerned topics. Also we were instructed how to use the "storyboard" function to design. At least we get introduced into the delegate concept and how it is useful with frameworks. This was very interesting for me thinking about the usage in mobile technology. One example was when using GPS. To use a call back system, instead of polling every time to lookup the current position is a smart idea, I think. At the end it was easy to develop some Apps for me.

This was important. Because, to complete the practical tasks, we had to develop an own app. One option was to do an own idea or just to do something with tasks around the "MapKit" framework. In the pictures you can see my final app. I had the idea to make an app of the predefined tasks wich is like a diary of places were you had been. If you are at an interesting place and want to note something about it, you can mark it in the map and write some infos to it into the pad. After that the app can inform you when you come back to that pace. One very difficult point was to make the switch between two views and transfer the data between them. Another difficult point was to enable the UI to rotate with the device and calculate the position and size of contained elements.
BTW: Later I forked this project to show the flight path of the ballon from the Stratoflights 2019 project (which you can find on this page in the Hardware section).

In the beginning of the module we started with the TCP/IP stack. We talked about the model it self and the kind of comunication using protocols. Also we got introduced into tools to watch and manage processec, openned connections, routings or else. Further we had a look on system interfaces, for example sockets. In the practical tasks we started writing a program that should recive packeges using the UDP protocol. After finished that we transform a server program of that. These both programms had the challenge to communicate with each other. The lecture continued with the TCP protocol. And the exercise continued than writing a client application for TCP which had to connect to a time service in the internet, that sends a timestamp back of the current time as a diffrence to the Unix Time, encoded in JSON. It was a nice moment when the timestamp appears on the terminal. At this moment I unterstood what the feeling of the old guys from the US American universitys was when they transmitted the first letter 'A' over the network. Was this challenge done, was beside this the first communication over the internet using the HTTP protocol done. After done that we had to write the corresponding TCP server application that replaced the server from the internet. By the way the challenge was that the server application should be able to handle mutiple clients that can connect. Unfortunately, caused by long delay (personally by the lecturer), we lost so much time, that we not talked about the IPv6 protocol or developed for it. But the grown interest for this topic is the source for me to go forward as in my job for software on the network and on the Linux kernel.

In the picture you can see the TCP server on the terminal and a Firefox. This time I used a Browser instead of useing my client program to connect. This was done because of when the connecting of my own program works is that fine. But a better thing is when I can choose any other Browser to connect and it not knows than it connects to my server.

In this module we started to havea look to the problem with scanf and buffers. We had the discourse about the risk handling adresses when programming in C. Further we lerned about using the compiler to prevent that "Eve" can inspect something about the behavior of an application or that the application can kill it self when data got manipulated. In the part of cryptographie we started having a look at some historical technologies like substitution. As an better idea we got introduced into "One Time Pad" and also why it has a limited security. Later we talked about cryptographie solutions which may are made only by business interests. For example syncron cryptos like DES. We alked about the function how DES encrypts and why it's not secure. Of course we talked about 2DES and why it's also not more secure. In this way we come over to AES. Also there we started with the function of AES. Later we lerned something about block lengths and how it is defined in AES. With this we come over to the topic about block chiffres and block chaining methods. We ended with the asyncron cryptographie technology in the module. Means: what ist that, how it works, what are the pros- and cons of that and why is a hybrid cryptographie better to use. Further we lerned something about hash algorithms and certificate chains. We lerned the algorithms of Deffie Helllman and RSA.

In the picture on the left you can see a task about safe programming in C. The goal of the task was to find out an input for this program that causes a failure that will start another application. In this case just a "harmless example" like xcalc. In the middle you can see a test to the vulnerability of a substitution chiffre on texts. By building a table with the probabilities of german words and the given text I was able to restore the original text. In another task we got a module from the professor which has written a code module to use AES and block chiffres. We had the task to practise the block chiffre modes by complete the high level API for the CBC and CTR modes. In the third picture you can see when a textfile of the Sherlock Holms oeuvre was encrypted and at least decrypted using the AES-CBC block chiffre. Above you see the Original text and below the decrypted text.

During this module we talked about relational databases. Particula topics were modelling as an ERM, understanding the Relational Model und Nomalization. Normal forms up to the thrid NF was also a difficult part. Compareable we liked relational algebra. Of corse we also lerned something about query a database using SQL. Beginning at "CREATE TABLE" over to some other query types up to DML. At the second part of the course we lerned something about set operations and joins. And also other views were done into this topic. For example we talked about query optimization and how the DBMS does that. Means parsing the query and optimize the allocation in the DBMS. We also take a look onto the DBMS it self. The background to work with transactions, how to handle multiple users, time access or lock data und how to handle errors. We take a particular view onto logging changes and doing backups of the data. Lastly we also talked about programming the database or using external programms to access. Means using stored procedures. And when programming using drivers to access the daabase and understand the use of the cursor concept.

In the practical tasks we had to try us do a data analyzation within our own database. For our anlyze we had the data which got public accessble 2006 by the AOL Research data leak and mirrored much times. Every group had to choose thier own idea, what they can evaluate with this data. With my partner I choose to analyze the market position of Nintendo, thier consoles and games and take a compare to other manufactors. One thought to take it as topic was that at this time the Wii console was published. On the mainpage you can see our data model. First we think about interesting questions to the topic and build our model to it. After that we tried to collect our own data about Nintendo form the AOL data. But this ist not easy. Because the people are searching in diffrent ways for diffrent intrests. Further it is difficult because people often use abbreviations for the console names, which are sometimes a part of another word, especially in english where for example "nes" is part of "business". After having the data in our database, we had to form queries that answer our questions. But after that, a doubled work phase starts. Because we still have to clearify which user had done which research. But for that we need console names or game names in our database to link them to the user. Therefor the names must be stored into the database, while be able to draw the results in graphics was also a task. For doing these tasks we had written mutiple python scripts and lerned, that python is a powerful programming language for database client software.

The Picture on the left shows the market share of Nintendo with other console manufactors at the year 2006 which depends on our collected data. The oth two pictures show parts of the python code that sends our queries to the database and transfered the results into the grafics.