CDTM stands for Center for Digital Technology and Management. It is an honors program jointly run by TUM and LMU in Munich for students who want to work somewhere between technology and business, usually because they want to start companies. I joined in the fall of 2016 and graduated in the summer of 2018. This year is roughly ten years out from when I applied, which made me want to write down what stuck and how it applies now.

Quick disclaimer on the word, since “agency” on Twitter has drifted into something close to a grindset cult, where the proof is how early you got up and how visibly you suffered. The version I picked up at Stanford and refined at CDTM is more grounded and more useful for me: the habit of acting on what reality is telling you, before anyone hands you permission or certainty, and usually before the next step is obvious. Most of the time it does not look like much: sending the email, showing up somewhere you were not formally invited, starting something for which nobody is asking you.

The seed in 2012

I was 17 in the summer of 2012 and spent a few weeks at a Stanford summer program for high schoolers. I had stumbled across it on my own while starting to research US colleges, and applied without anyone pushing me to do so. Partly because I did not yet have plans for the long American summer break I was still not used to — having grown up in Germany, where the longest school break was only six weeks. I lived on campus, took real Stanford classes, and ate in the same dining halls as the regular students. I was halfway through high school in Worcester, Massachusetts at the time, so I had already absorbed a lot about how American universities work.

What drew me in was not the classes. It was watching the actual Stanford students around me. They were starting companies, joining ones that two friends had started the week before, building things in dorm rooms, cold-emailing professors, walking into labs and asking to help. Nobody was waiting for someone to give them permission, and nobody was waiting for the path to look obvious before they started walking on it.

I went back to Worcester and tried to act like the Stanford students, and it stuck. I launched Anigmo.org with online “Tic-Tac-Toe” and “Connect Four” games that you could play against the computer and wrote my Worcester Academy capstone about it, which is still on the research page. A small anagram generator, a sudoku web app, and a screenshot tool called Screen followed, all still listed on the projects page. Nobody had assigned any of it, and that was the point. I simply got into the habit of having an idea and executing on it — for no apparent reason other than enjoying the building process itself — and taking it one step after another.

I graduated in 2013, moved back to Munich, and started at TUM that fall. I freelanced through most of undergrad and ran a small consulting company called CW Technologies on the side. By the time I applied to the CDTM in 2016, I already thought of myself as someone who builds things, but I had not yet seen what it looks like when a whole room operates that way.

CDTM: the proof at scale

The thing about CDTM is that you are surrounded by other people who act. Self-selection does most of the work. Students apply because they want to build startups, the program filters for the ones who already start things on their own, and the result is two years of being in rooms where the default question is not whether something can be done but who is going to do it.

CDTM did not give anyone agency — everyone there already had it. What it added was a structured place to nurture that habit and point it at problems that mattered.

Not everything CDTM gave me was about agency, and the Trend Seminar is a good example of that. It was more about timing: how to read an emerging space and form a view on when something is ready to be built and accepted by a market. Different than the computer games I built as a high school student that no one really needed. You pick a topic, study it for many weeks, and write a report on it that’s printed and shared online for anyone to read. Our cohort looked broadly at diabetes, and my own subgroup argued that automatic closed-loop systems for managing insulin intake were the future. They were not yet a real consumer category in 2016, when the first hybrid system had only just received FDA approval and there was nothing you could really buy off a shelf. A decade later, automated insulin delivery is the ADA-recommended treatment for type-1 diabetes, with five FDA-approved systems on the market.

The point was less the report and more the muscle of taking a vague trend and turning it into something concrete that other people can argue with. I still use that muscle when I try to point remberg in a direction.

The other half of CDTM was the project work. MPD (Managing Product Development) is the course where a small team takes on a real product brief from an industry partner and runs with it for a semester. A European aerospace company gave my team a spec in 2016 for an internal assistant to help their engineers look up technical documentation. We put chat front and center, which was not the obvious answer at the time, well before LLMs made it the default interface for everything. One of my classmates had a deep NLP background and ran with that part of the stack.¹

In hindsight, what we shipped looked almost exactly like the AI assistants every enterprise is rolling out now, just with much worse intent classification and no real generation underneath. The point of MPD was not the chatbot, of course; it was that you spend a semester acting as if you actually own a product and a customer relationship, and after a couple of semesters built that way you stop expecting a syllabus to tell you what to do.

Two of my three co-founders, the original introduction to remberg, and several of our best hires all came through the CDTM network. Being in the room with people who already act is most of what makes any of this work.

What shaped me further was the time abroad. CDTM had a connection to the chair at the Georgia Tech Research Network Operations Center, and that introduction was the only part of getting to Atlanta that came from the program. Everything else I had to figure out myself: the visa, the flights, housing once I got there, the research project I wanted to work on, and getting into the courses I wanted to sit in by just walking in and asking the professor. The semester after that I did the same thing at MIT, starting again from a single introduction and building the rest of the stay myself. Those two semesters are the closest CDTM ever got to formal training in agency, except that nobody framed it as training — it was just what you did.

I wrote about the Georgia Tech semester in Studying at the Georgia Institute of Technology shortly after it finished. Re-reading it now, the through line is plain: the research, the courses, the social side, almost all of it you have to build for yourself.

What it looks like now

remberg is what came out of all of that. It started during my MIT semester in the spring of 2018. I was on a research track, writing papers, getting published, and starting to find academia intriguing. I was also interviewing with strategy consulting firms on the side, which was the other path that felt safe at the time. Then the offer came through the CDTM network: three guys back in Munich were building something together and were looking for a fourth person on the software side.² Saying yes meant not finishing my master’s degree, dropping the research track, and stepping off the consulting interview pipeline. Pushing against the path my family and broader society expected of me was a real struggle, and probably the hardest piece of agency I have had to find. I am very glad I did it.

We started with a hardware product called Wunderbox, pivoted quickly to an after-sales SaaS for equipment-as-a-service, and over time landed on a maintenance management system for industrial customers. Each of those pivots was, in retrospect, an act of agency: looking at what reality was telling us and changing what we were doing instead of waiting for permission to change it. There were many more micro-shifts in between, like in most startups, but writing about the evolution of remberg is another job in itself.

My own scope in those years stretched well past what a CTO normally owns. I leaned into finance, legal, and operations as well, making the calls in those domains rather than just executing the tasks. I had some prior exposure to those areas, and a family member in tax consulting I could ask when I got stuck. The rest I just took on, because on a four-person founding team nobody else was going to. Hiring a Head of Finance in 2022 took a lot of that load off, and bringing in a VP Operations more recently took even more. That has finally let me focus fully on AI and engineering again.

My job as CTO inside remberg has changed shape every year or two. 2018 was prototyping. 2019 to 2021 was being a software engineer. 2022 was hiring and being a more public face for the company while we grew from 15 to 70 people, a lot of that in product and engineering, which meant trading days of writing code for back-to-back hiring calls and being a more extroverted version of myself than I find natural. 2023 was organizational design and, at the end of the year, letting go of people across product, design, and engineering, a decision I think we came out of stronger. 2024 was building up the velocity in product and engineering. 2025 and 2026 have been pulled back to engineering, infrastructure, and architecture, with the Head of Engineering doing a tremendous job at running the organization. None of those transitions felt like a job description being handed to me, but like noticing what was missing, what the company needed at a certain time, and stepping into it.

Should you still do CDTM in 2026?

I get this question occasionally from people who are deciding between top European programs in the AI era. The short version of my answer is a simple yes. The three things CDTM gave me that have aged well are the habit of self-organizing whatever comes next, the people I am still in the room with, and a sense of how to read where a market is heading. AI does not weaken the need for any of them. If anything, the surface area of what a small motivated group can build has expanded a lot in the last two years, and the bottleneck has moved further toward whether you actually start. Pick a program where the people around you act, and act around them.

If you cannot apply to a program like CDTM, the conditions are reproducible without one. Find a small group of people who already build things in their spare time, pick a deadline together (even one you make up), and ship something against it.

A second lever is unsolicited work: pick a question that an industry partner would pay to have answered and answer it for free. Volunteer in a lab, write to a researcher, run a one-day hackathon, take a customer call you have no business taking. None of that requires admissions, and most of the lift of CDTM came from doing exactly those things in a room where everyone else was doing them too.

Find me on X or write me an email if you have any questions.

Let’s start by talking about what I actually worked on.

My Research

While I was trying to find a topic for my thesis at the beginning of 2017, I stumbled upon the area of fog computing. Fog computing is a rather new terminology which extends the concept of cloud computing to the edge of the network. As we look at computing systems that span traditional server farms as well as smaller devices located closer to where they are being used, new issues emerge. Deploying software on all these different, heterogeneous devices is more complicated than for cloud computing. And, while many deployment solutions for cloud computing exist, there hasn’t been that much focus on deployment in fog computing environments. In my work, I focused on using Kubernetes, a deployment and orchestration system developed by Google, in a fog computing setting. I developed a process for using it for fog computing and validated how well the system can work.

After I finished my thesis in the summer of 2017, my supervisor convinced me to publish a paper about this work. This meant reworking some of my findings and results. I had to squash my seemingly endless thesis into a 6-page paper. While it takes a lot of effort to figure out which pieces are the most essential, the process also helps to better understand your own work.

Feel free to read through the final abstract or learn more about the topic on my research page.

Devices used in fog and edge computing are heterogeneous, decentralized and distributed. These computing environments are unpredictable and their applications are becoming more complex. This leads to challenges regarding deployment and management of fog and edge applications. It is important to ensure that quality of service, availability, reliability and real-time characteristics are guaranteed during deployment to take advantage of fog computing. In this paper, we present Fogernetes, a fog computing platform that enables management and deployment of fog applications with specific requirements on heterogeneous devices with different capabilities. Fogernetes allows matching requirements of application components with device capabilities by using a labeling system. Based on a case study, we evaluate and test Fogernetes and examine its practical applicability for the deployment and management of fog computing applications. Fodeo serves as an example application. Fodeo analyzes video streams from multiple cameras and detects objects in them. Fogernetes enables the deployment of Fodeo components on appropriate devices by matching requirements and capabilities.

Publishing Process

Publishing a paper isn’t always a straightforward process. Let’s check out the timeline of the entire process:

• August 2017 - I started my semester abroad after submitting my thesis. We decided to try and publish at a conference. 💪
• September 2017 - We had to find the right conference and prepare a short paper summarizing the findings. ✍️
• October 2017 - We decided to submit the paper to the IC2E 2018 conference. 📨
• December 2017 - I am finishing my semester abroad, we received news that we were not accepted. The year 2017 was almost over, and we had nothing to show for it. 😟
• January 2018 - With the new year lending us energy, we decided to go for another round. We aim to submit for the DOMINOS 2018 workshop at the NOMS 2018 conference in Taipei. 💪

It has now been one year since I first learned about this research topic.

• February 2018 - After getting an unforeseen extension on the deadline, we were able to successfully submit the paper. 📨
• March 2018 - The big news: we were accepted. 🎉
• March 2018 - If you are fortunate enough to be accepted at your conference or journal of choice, the work is not over. I also had to prepare a presentation and a poster. 🏋️‍♀️
• April 2018 - The conference happened in Taipei. I was lucky enough to get some funding to present the work. 🌏
• August 2018 - The paper finally shows up in the IEEE library. 📚

It has now been one year since I submitted my thesis and more than 18 months since I started to look into this topic.

As you have realized by now, this whole process can take quite some time. It took forever, from the first time I approached my supervisor about the topic, to eventually having the work published in conference proceedings. While I did find the research, the publishing work, and the entire process quite rewarding and insightful, I also realized that I would face this issue again if I decided to continue with a career in research. With computer science being such a fast-moving field, the pressure to get published and the headaches you get during this long process can distract from the actual work. I spent the past year “just getting published” (at least it felt like that) and not actually doing the stuff that interests me. And while this was rewarding the first time, I currently feel as if this would get annoying rather quickly. Here in Germany, universities are in a fight with Elsevier. You quickly realize how this publishing system is in some ways inherently broken. It is frustrating. This is why I have decided to just put some of the other stuff I did on ArXiV and be done with it. Currently, it doesn’t seem worth investing so much time into this processes. I do believe that it would become easier with more experience.

I want to point out that:

• I would definitely do it again, as I have learned a lot.
• Getting published is not as infeasible as it may seem in the first place.
• Anyone who is pursuing a research project and is thinking of doing it should go for it.

For me, the true challenge has become to work on something that is so interesting, so unique, and so rewarding that I do not need a conference or a journal to make other people aware of my work. After all, this is why I started this blog in the first place. For now, that means I am done with traditional publishing and I will try to find my own process, let it be in research or with something else.

TL;DR

1. Doing research is liberating and fun. You can truly pursue what you are interested in.
2. The long timelines of conferences make it quite hard to focus on doing actual work.
3. Exchanging ideas at a conference and presenting your work is very rewarding and it is an amazing opportunity to meet some of your peers.
4. I would recommend everyone I meet to try to publish their work.
5. In the future, I will just continue to upload my papers here or on ArXiV.

Thank you

Finally, I want to say: Thank you!.

Thank you to the Chair for Applied Software Engineering at the Technical University Munich where I have been a student assistant since 2015. Thank you to Prof. Bruegge for having taught me so much and making my research and especially this trip possible in the first place. Also, thank you to Andreas Seitz for guiding me throughout this time. From the first pages of my thesis to the final version of my own published work, I could not have done it without him.

I am happy to say that I finally updated my command line tools, pen and como, to adhere to the XDG standard. The new location for their data files will be in $XDG_DATA_HOME or in $HOME/.local/share, depending on whether the former environment variable is set. You will now find new versions for both tools at PyPi:

• pen v0.4.1
• como v0.6.2

You can upgrade with pip install como --upgrade and pip install penpal --upgrade.

Pen

The new default location is: $XDG_DATA_HOME/pen/pen

Please be aware that no automatic migration will take place. If you have previously configured the path of your data file with the pen path command, the program will still adhere to this setting. Otherwise, you can either move the data file to the new default location or you can reconfigure your old path.

Como

The new default location is: $XDG_DATA_HOME/como/como

Again, please be aware that no automatic migration will take place. You can either export your data before the upgrade (or download it from como.cwoebker.com) or you can simply move the data file to the new location manually.

In other news I also updated como so that it now supports MacOS Mojave.

Feedback requested!

If you try out these new versions, please let me know if you encounter any issues or problems. I will do my best to fix them as soon as possible.

Just two weeks ago, I saw a tweet by @holman, complaining about the current state of favicons on the internet. For those of you who don’t know what a “favicon” is: It is short for favorite icon and is a small image that is representative of a website. It usually shows up before the url or inside of a tab in your browser. After I saw this tweet, I decided to also improve this website in order to support the favicon rules of 2018. Back in the early days of the internet all of this was rather straightforward. All you needed was a favicon.ico file in the root directory of your website and you would be all set and ready to go. And today this still works for the most part, but different companies have established new standards in order to use website logos in places such as mobile device home screens or pinned tabs.

In this post, I will list and describe the files that I use on this blog to adhere to these various standards, as well as point you to an easy-to-use solution to do the same! So let’s make sure my beautiful favicon shows up everywhere!

Favicon: Overview

In the table below, I list and describe the different files that I made available at the root of my website:

In general, I have also found audreyr’s github project favicon-cheat-sheet to be really helpful on all of this. Next, we will look at the actual HTML code needed to tell different browsers about all these files.

Favicon: HTML

There are four different standards to support if you want to cover the majority of clients and use cases. On the one hand, we need to make sure to adhere to the original favicon standard. On the other hand, we also want to comply with the new standards put forth by Apple, Google, and Microsoft. These new standards, like described in the table above, are mostly there to have a website image that can be used on a mobile home screen, a tab, or a computer desktop.

In order to tell the browsers about some of these files, I also added the following to the <head> of my webpage.

<link rel="icon" type="image/png" sizes="32x32" href="/favicon-32x32.png">
<link rel="icon" type="image/png" sizes="16x16" href="/favicon-16x16.png">
<link rel="manifest" href="/site.webmanifest">
<meta name="application-name" content="cwoebker">
<meta name="theme-color" content="#ffffff">
<meta name="msapplication-TileColor" content="#516930">
<meta name="msapplication-TileImage" content="/mstile-150x150.png">
<meta name="apple-mobile-web-app-title" content="cwoebker">
<link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png">
<link rel="mask-icon" href="/safari-pinned-tab.svg" color="#516930">

Favicons: Simple Solution

If you also want to adhere to these rules, you don’t have to figure everything out by yourself. There are various online tools that can automatically generate all the necessary code and files for you. I used https://realfavicongenerator.net. You can also use this tool in order to check for any current issues with your favicon configuration.

Stay tuned for my upcoming post about automating your deployments with gulp if you want to learn more about my current website setup. For the original build that this whole site is layered on top of, see Jekyll Blogging.

Georgia Tech

Georgia Tech, short for the Georgia Institute of Technology, was founded in 1885 and is located in the heart of Midtown Atlanta. With roughly 25,000 students it is one of the larger technical universities in the US and consistently ranks among the top ten public universities in the country. The College of Engineering and the School of Computing are the strongest programs — both usually land in the top five nationally. What makes the campus feel a bit different from most US schools is how embedded it is in the city. Tech Square, just across the highway from the main campus, is where a lot of the research institutes and startups are concentrated, which blurs the line between university and industry in a way I found pretty interesting.

Research Network Operations Center

I spent most of my time at the Georgia Tech Research Network Operations Center, or in short, GT-RNOC. The RNOC is led by Russ Clark and Matthew Sanders. It is a research institute located at Tech Square right in midtown Atlanta and just over the highway from the main campus. The main focus of their work is in the area of mobile application systems, networked devices, and the internet of things. They also run a smart home setup that serves as a testbed for various IoT projects. The team is quite interdisciplinary — people come from engineering, computing, and design, and a good amount of the work is done in cooperation with external companies.

My Work

During my time at Georgia Tech, I had the chance to work on multiple different projects and applications. As a visiting researcher at RNOC I created a new cluster management system as a self-serve platform based on OpenShift Origin.

For my own research project I evaluated the applicability of existing orchestration frameworks in the area of IoT. I set up a small Raspberry Pi cluster and evaluated the performance of some of the major orchestration providers. If you are curious about my research projects in general, you can find more on my research page.

Finally I took part in the Convergence Innovation Competition (CIC) at Georgia Tech. With our application Avocado we won the 2nd prize in the category Health & Wellness.

(project poster)

My Life

Of course, apart from the work I did at the RNOC, I also had the chance to explore the social life surrounding Georgia Tech and Atlanta. Early in the semester I went through fraternity orientation, which was interesting to witness up close — it is quite a different culture from what I was used to in Germany. Football season was another highlight: watching the Yellow Jackets play at Bobby Dodd Stadium in the fall is a pretty big deal around campus and I enjoyed every minute of it. I also made it out of the city a few times — a hiking trip through Tennessee was a great way to decompress after a long stretch of work.

Outlook

Right now, after having enjoyed the holidays back home, I am at MIT in Boston doing another exchange, after which I plan to return to Munich to continue my master’s degree. Let me know if you have any questions or want to learn more about life as a visiting researcher.

This aversion towards learning vocabulary made it impossible for me to make progress back then. Creating habits around language learning and simplifying the learning process changed that for me.

I’ve tried out Duolingo before, and while I liked the playful approach of collecting points and opening up additional content it never quite caught on with me. I never felt like Duolingo would be able to provide me with everything I needed to know about a language and I was put off by the prospect of having to learn spanish for multiple years without making reasonable progress towards fluency. Additionally I learned about an application called Anki through a polyglot named Gabriel Wyner. After having been quite successful in learning multiple languages himself, Gabriel Wyner created a project called Fluent Forever. Using the Anki application, he provided some decks that help you to learn the basic words and sounds of a language. Inspired by the prospect of learning a new language in a rather short amount of time and with a simple mobile application, I reevaluated how I could reach my goal. I came up with a three-phase plan, which I am still adhering to as of today:

1. Start by learning as much vocabulary as possible. Create a daily habit of learning 10 to 20 new words each day. Define a goal for how many words I want to learn.
2. Begin to read and watch spanish media: Books, movies, tv shows, etc.
3. Get into regular contact with native spanish speakers in order to get used to the language and figure out the grammar of the language.

Right now, I am at the end of the first phase. I have used Duolingo and Anki to make it as easy as possible for me to keep up with my daily habit. Actually, I finally reached a year-long Duolingo streak just recently. For Anki I’ve been using a deck from their large public online collection. (Due to the fact that Anki keeps track of a bunch of different statistics, I am planning on doing another post once I finish this deck to dive into some of those numbers.)

Until recently, I wasn’t quite sure whether this whole plan would ever work out. But then, a couple of weeks ago, I was in Mexico visiting an old high school friend of mine. And to my surprise, my vocabulary was good enough to create basic sentences and understand a lot of different conversations during my day-to-day activities.

Of course, I need more practice and immersion to make this perfect, but by starting out with a larger collection of words you take away a huge hindrance on the way to achieve fluency. Mastering this vocabulary allows you to truly focus on the conversations, the grammar and other important quirks of a language.

What comes next is going to be more difficult: mastering Spanish. From here on out keeping up with my habit will not be as easy as opening up a mobile application every day, but I hope that I will find a way that works for me. Time will tell if I can immerse myself enough to achieve my goal.

If any of you have any tips or ideas on what else might help, let me know. I would love to hear your thoughts!

If you log in to a server with ssh, you can type the following three characters: Enter, ~, and ?. The result should look similar to this:

Supported escape sequences:
 ~.   - terminate connection (and any multiplexed sessions)
 ~B   - send a BREAK to the remote system
 ~C   - open a command line
 ~R   - request rekey
 ~V/v - decrease/increase verbosity (LogLevel)
 ~^Z  - suspend ssh
 ~#   - list forwarded connections
 ~&   - background ssh (when waiting for connections to terminate)
 ~?   - this message
 ~~   - send the escape character by typing it twice
(Note that escapes are only recognized immediately after newline.)

Turns out, you can control SSH using escape sequences that aren’t executed on the server like all the other input, but used to control the local client. To solve the issue described above we can just enter: Enter, ~, and . and terminate the current connection.

I will describe the purpose of the escape sequence below:

~. - Ends the current connection right away.

~C - Allows you to edit forwarded connections

~R - Should be done automatically by current SSH versions anyway.

~V/v - Change log levels on the fly.

~^Z - Suspends the current ssh connection and puts you back into a local shell. Allows you to return to the ssh session using fg.

~# - Lists all forwarded connections

~& - Puts SSH in the background and waits for all processes to exit gracefully.

~? - Print the help message you can see above.

~~ - Allows you to actually send the ~ character after a newline.

I am still trying to find a good explanation for ~B. Let me know if you can point me in the right direction.

These escape characters are described in the man pages of ssh. If you live in your terminal, the tricks above pair well with a comfortable local shell — see my notes on switching to zsh.

Fast-forward a few weeks, and I decided to try to learn Spanish with Duolingo. Duolingo has a notable “streak” feature that shows how long you have kept your daily learning goal, day after day. To make sure I would show up, I added a simple daily task to my list and checked it off. Since I had made such a habit out of completing all my daily tasks, I always felt the need to actually complete all of them every day. My goal is to complete all Duolingo exercises and reach a year-long 365-day streak. At first, sticking with 10–15 minutes of Spanish every day was not easy, but it became easier with time. The todo list helps me to divide work into smaller chunks and enables my habits. Doing something just for a short time each and every day can have a more profound impact on your behavior and your life. Now I use both Duolingo and another application called Anki and I hope to write another post on my experience of learning a new language with these applications. With Duolingo, I just hit a 300-day streak today.

The important thing is to never miss a day of studying. Of course, there will be times where you cannot make it work, but that should be the rare exception. If you have an important exam the next day? You keep learning. If you still have to run tons of errands before tomorrow? You keep learning. If there is something else on your mind that stops you from staying focused? You keep learning. The learning needs to become a habit like brushing your teeth or sleeping. These few minutes every day help tremendously throughout the learning process. Once you have made it a habit to study every day, it stops feeling like a burden, it does not get in the way of your other work, and you feel more productive overall.

Habits are powerful. BJ Fogg, PhD, Director of the Persuasive Tech Lab at Stanford University, has studied this phenomenon for more than 20 years. He has found that there are three different things that can change human behavior:

• Option A - Have an epiphany
• Option B - Change your environment (what surrounds you)
• Option C - Take baby steps

Option C is the one you can control most easily. You can build habits that add up to small steps and change your own behavior when learning something new. I can only urge you to try the same. What areas of your life could you improve with a few minutes a day?

From the archive

A couple of weeks ago I did an overall upgrade of my server and moved this jekyll blog from Heroku’s servers over to my own dedicated machine. During this process I also gave my blog an overhaul and added SSL encryption and made it more efficient by minimizing more resources and adhering to Google’s PageSpeed Best Practices.

Simplifying Deployments with Docker

The new setup is based on the awesome dokku, a docker-powered Platform as a Service (PaaS). Coming from the heroku platform it now allows me to quickly deploy changes of my webpage and host it on my own machine. Furthermore I can run multiple different applications that are isolated from each other (anagram, screen, sudoku). But Docker can provide even more benefits:

• Rapid application deployment – containers include the minimal runtime requirements of the application, reducing their size and allowing them to be deployed quickly.
• Portability across machines – an application and all its dependencies can be bundled into a single container that is independent from the host version of Linux kernel, platform distribution, or deployment model. This container can be transferred to another machine that runs Docker, and executed there without compatibility issues.
• Version control and component reuse – you can track successive versions of a container, inspect differences, or roll-back to previous versions. Containers reuse components from the preceding layers, which makes them noticeably lightweight.
• Sharing – you can use a remote repository to share your container with others. Red Hat provides a registry for this purpose, and it is also possible to configure your own private repository.
• Lightweight footprint and minimal overhead – Docker images are typically very small, which facilitates rapid delivery and reduces the time to deploy new application containers.
• Simplified maintenance – Docker reduces effort and risk of problems with application dependencies.

To setup an application with dokku I just had to create a simple Dockerfile. It is based on the official ruby image and adds node and yarn to the mix.

FROM ruby

... # install node.js and yarn (see https://github.com/nodejs/docker-node/blob/a82c9dcd3f85ff8055f56c53e6d8f31c5ae28ed7/7.9/Dockerfile)

Afterwards I install all dependencies through yarn, gem and bower.

ADD . /app
WORKDIR /app

RUN yarn global add node-gyp
RUN yarn install
RUN bundle install
RUN yarn run bower
RUN yarn run gulp

Finally I can build the site with the jekyll command.

ENV JEKYLL_ENV production
RUN bundle exec jekyll build

EXPOSE 5000
CMD ["bundle","exec","unicorn","-p","5000","-c","./unicorn.rb"]

Docker Caching Issues

One major issue I encountered was that changes often took a while to be pushed. Each time I change any small file, e.g. correct a typo on a blog post, docker would reinstall the entire blog with its dependencies. Usually Docker is smart about this and keeps a cache of the different parts of the Dockerfile. But if you added something to the docker context and something changes docker has to restart from there. Since I added my complete project folder at once, any change, as small as it might be, always triggered a complete rebuild of my application.

Dependency Jungle

The steps of the process that took the most time were the dependency installations. For my blog I use three different commands that take a longer time to execute:

• The ruby gem command
• The node.js yarn package manager
• The bower tool for html components

Ideally I still would like to test my blog under the same conditions as on the server. If I would have to reinstall all dependencies every time I make a minor change that would slow me down drastically. So what do we do about this?

Solution

To ensure that dependencies are only reinstalled when the corresponding configuration changes we have to selectively add the files to the docker image.

For my blog these files are:

• Gemfile (Ruby)
• package.json (Node.js)
• bower.json (bower)

Dependency Files

We have to add these 3 files beforehand. And furthermore install the dependencies in a global or temporary location so that we can add them back to the rest of the application later.

Gemfile

ADD Gemfile /tmp/Gemfile
ADD Gemfile.lock /tmp/Gemfile.lock
RUN cd /tmp && bundle install

package.json

RUN yarn global add node-gyp
ADD package.json /tmp/package.json
RUN cd /tmp && yarn install
RUN mkdir -p /app && cp -a /tmp/node_modules /app/

bower.json

ADD bower.json /tmp/bower.json
RUN cd /tmp && yarn run bower

Ordering

Depending on which configuration file changes, all the steps that come afterwards have to be executed again. If we want to be smart about our approach, we can order the different installation steps in a more efficient way. In my case this would be:

1. yarn
2. gem
3. bower

For my application bower dependencies are changed the most frequent, so I install it last. After that I sometimes install new jekyll plugins. And finally comes yarn, where there are mostly just development requirements like gulp that almost never change and I therefore install it right at the beginning.

Result

Final Words

Of course you can use a similar setup for all kinds of dependencies and installation steps that you have. The core idea is to selectively add the files and build your docker image on a step-by-step basis.

Below you can find the final version of my Dockerfile. Don’t hesitate to ask, if you have any questions!

FROM ruby

RUN groupadd --gid 1000 node \
  && useradd --uid 1000 --gid node --shell /bin/bash --create-home node

# gpg keys listed at https://github.com/nodejs/node
RUN set -ex \
  && for key in \
    9554F04D7259F04124DE6B476D5A82AC7E37093B \
    94AE36675C464D64BAFA68DD7434390BDBE9B9C5 \
    0034A06D9D9B0064CE8ADF6BF1747F4AD2306D93 \
    FD3A5288F042B6850C66B31F09FE44734EB7990E \
    71DCFD284A79C3B38668286BC97EC7A07EDE3FC1 \
    DD8F2338BAE7501E3DD5AC78C273792F7D83545D \
    B9AE9905FFD7803F25714661B63B535A4C206CA9 \
    C4F0DFFF4E8C1A8236409D08E73BC641CC11F4C8 \
    56730D5401028683275BD23C23EFEFE93C4CFFFE \
  ; do \
    gpg --keyserver ha.pool.sks-keyservers.net --recv-keys "$key"; \
  done

ENV NPM_CONFIG_LOGLEVEL info
ENV NODE_VERSION 7.7.2

RUN curl -SLO "https://nodejs.org/dist/v$NODE_VERSION/node-v$NODE_VERSION-linux-x64.tar.xz" \
  && curl -SLO "https://nodejs.org/dist/v$NODE_VERSION/SHASUMS256.txt.asc" \
  && gpg --batch --decrypt --output SHASUMS256.txt SHASUMS256.txt.asc \
  && grep " node-v$NODE_VERSION-linux-x64.tar.xz\$" SHASUMS256.txt | sha256sum -c - \
  && tar -xJf "node-v$NODE_VERSION-linux-x64.tar.xz" -C /usr/local --strip-components=1 \
  && rm "node-v$NODE_VERSION-linux-x64.tar.xz" SHASUMS256.txt.asc SHASUMS256.txt \
  && ln -s /usr/local/bin/node /usr/local/bin/nodejs

ENV YARN_VERSION 0.21.3

RUN set -ex \
  && for key in \
    6A010C5166006599AA17F08146C2130DFD2497F5 \
  ; do \
    gpg --keyserver ha.pool.sks-keyservers.net --recv-keys "$key"; \
  done \
  && curl -fSL -o yarn.js "https://yarnpkg.com/downloads/$YARN_VERSION/yarn-legacy-$YARN_VERSION.js" \
  && curl -fSL -o yarn.js.asc "https://yarnpkg.com/downloads/$YARN_VERSION/yarn-legacy-$YARN_VERSION.js.asc" \
  && gpg --batch --verify yarn.js.asc yarn.js \
  && rm yarn.js.asc \
  && mv yarn.js /usr/local/bin/yarn \
  && chmod +x /usr/local/bin/yarn

RUN yarn global add node-gyp
ADD package.json /tmp/package.json
RUN cd /tmp && yarn install
RUN mkdir -p /app && cp -a /tmp/node_modules /app/

ADD Gemfile /tmp/Gemfile
ADD Gemfile.lock /tmp/Gemfile.lock
RUN cd /tmp && bundle install

ADD bower.json /tmp/bower.json
RUN cd /tmp && yarn run bower

ADD . /app
WORKDIR /app

RUN mv /tmp/bower_components source/_assets/components
RUN yarn run gulp

ENV JEKYLL_ENV production
RUN bundle exec jekyll build

EXPOSE 5000
CMD ["bundle","exec","unicorn","-p","5000","-c","./unicorn.rb"]

What is BOINC?

BOINC is an open-source software for volunteer computing that was started at UC Berkeley. It allows anyone to contribute to scientific advancements simply by using their home computer. Researchers and Scientists can create projects that need a high amount of computing power and ask for people around the world to participate and support their efforts.

In the past BOINC was part of some interesting scientific advancements:

• In February 2010 the FightAIDS@Home project scientists announced that they found two compounds that make a completely new class of AIDS-fighting drugs possible.
• In June 2013 the Clean Energy Project published a database of over 2.3 million organic molecules which have had their properties characterized. Of these, 35,000 molecules have shown the potential to double the efficiency over organic solar cells being produced nowadays.
• In February 2014 the Help Fight Childhood Cancer project scientists announced the discovery of 7 compounds that destroy neuroblastoma cancer cells without any apparent side effects.
• In July 2015, the Computing for Clean Water project announced that a paper had been published on the Nature Nanotechnology journal describing how they have discovered a new way to filter water much faster than previously thought.

How to setup BOINC

Setting up the BOINC software is pretty simple. If you are using a desktop computer (Linux, Mac, or Windows) simply download the software. If you have a headless system you can find a tutorial for your operating system here. Afterwards you have to sign up for projects that interest you. I can also recommend using a project manager such as the BOINC Account Manager (BAM) or Grid Republic.

My Boinc Setup

I have two computers that work on BOINC projects for me. On the one hand I use any spare capacity on my home gaming PC for calculations. You can adapt the BOINC settings so that the CPU is only used while not actively using the computer. On the other hand I use a quarter of the server CPU, where I host this blog, to contribute 24/7.

My Boinc Projects

So far, I have decided to join the following BOINC projects:

1. World Community Grid. Help all kinds of medical research projects.
2. PrimeGrid. Finding new & large prime numbers.
3. GPU Grid. Using your GPU for a distributed computing infrastructure devoted to biomedical research.

Boinc Statistics

World Community Grid

Final Words

Let me know in the comments, if I was able to convince you!

Now I can only say: Come, join me, and save the world. 😉