<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Andrew van Rooyen on Medium]]></title>
        <description><![CDATA[Stories by Andrew van Rooyen on Medium]]></description>
        <link>https://medium.com/@andrewvr?source=rss-67b3c62ddae7------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*wuHzEyor-r7mXvusjlJG6Q.jpeg</url>
            <title>Stories by Andrew van Rooyen on Medium</title>
            <link>https://medium.com/@andrewvr?source=rss-67b3c62ddae7------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 16:01:47 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@andrewvr/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Learning the hard way: Microservices]]></title>
            <link>https://itnext.io/microservices-c8b5dbdd58b8?source=rss-67b3c62ddae7------2</link>
            <guid isPermaLink="false">https://medium.com/p/c8b5dbdd58b8</guid>
            <category><![CDATA[retrospectives]]></category>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Andrew van Rooyen]]></dc:creator>
            <pubDate>Wed, 11 Sep 2019 14:29:52 GMT</pubDate>
            <atom:updated>2019-09-12T11:20:18.157Z</atom:updated>
            <content:encoded><![CDATA[<h4>A retrospective on how I ignored the rules and regretted it</h4><figure><img alt="A blueprint of a microservice architecture, annotated with “what could possibly go wrong?”" src="https://cdn-images-1.medium.com/max/1024/1*W7hsdjQUl8Eax9Bwn6BXnA.png" /></figure><p>In late 2016, my team and I started building a brand new platform. Having a blank slate like this is a developer’s dream — no legacy code, no backward compatibility to worry about, and best of all, we could choose The Right Technology™ for the job.</p><p>Three years later, after much pain and suffering, I’m here to do a bit of a retrospective. Before diving in though, I’m going to acknowledge two things.</p><ul><li>Hindsight is 20/20</li><li>There is no silver bullet</li></ul><p>There’s no way of knowing if doing things differently would have resulted in less frustration, but there were definitely some key pieces of <em>very important</em> advice around domain/architecture which we chose to ignore. At the time, we thought we knew better.</p><p>So for those who are embarking on similar journeys, here are some of the biggest pieces of advice I regret not taking.</p><h3>Ignored advice #1: Conway’s Law</h3><p><a href="https://en.wikipedia.org/wiki/Conway%27s_law">This law</a> states that inevitably, your system’s architecture will in some way resemble the organisational structure of your company.</p><figure><img alt="A diagram of an org chart mapping onto a system architecture" src="https://cdn-images-1.medium.com/max/1024/1*uXHAjirk-cFsvOj6t0QV2A.png" /></figure><p>As our platform has evolved, we’ve written and operated between 30 and 40 microservices, depending on how you count. Not all still exist, some have been rewritten in a different language, etc.</p><p>The catch is that since we started building, we were never more than a handful of backend developers. Because we were always a small, close-knit team, each developer would work on all the services. Architecture decisions were made as a group, and being on call meant dealing with potential issues in any area.</p><p>As you can probably guess from the high service-developer ratio, we ended up with lots of “separated” yet tightly-coupled services. This hurt us a lot.</p><p>Because of the coupling, there was an incessant temptation to reduce our workload by “just” deploying cross-service changes at the same time, which flies in the face of the <a href="https://youtu.be/PFQnNFe27kU?t=1352">deploy independently</a> principle.</p><h3>Ignored advice #2: You aren’t Google</h3><figure><img alt="A small dot representing you, next to a large stick figure representing Google" src="https://cdn-images-1.medium.com/max/1000/1*0tG8wjC8cB2bNg9cIRki6Q.png" /></figure><p>One of the lesser benefits of microservices is that they can scale independently. In our initial design, we had already separated components which were expected to be bottlenecks at scale. Reality check: It turns out the scale where this would matter is way beyond anything we are likely to encounter.</p><p>In fact, not only were we guessing about domain boundaries, but each service also came with a certain amount of overhead. We run a collection of sidecar containers and <a href="https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/">Kubernetes Daemonsets</a> for operations functions (like monitoring and logging). It got to a point where we were spending more resources on the supporting infrastructure than our actual application. By a large amount.</p><p>Now, I’m not saying we’d be better off with a monolith, but if we had started with a simpler architecture, we could have:</p><ul><li>Broken off pieces as we became more confident in the domain and found the right abstractions</li><li>Gathered data around where the real performance bottlenecks were, if that even became a problem</li><li>Saved a bunch of money by overlapping the supporting infrastructure</li></ul><h3>Ignored advice #3: You still aren’t Google</h3><figure><img alt="A small dot representing you (again), next to a large stick figure representing Google" src="https://cdn-images-1.medium.com/max/1000/1*uWUHdJ7YMo16yZi-0bXyjw.png" /></figure><p>Another benefit of microservices is the freedom to choose the best tool for the job. We were experimenting with languages, and were running services written in <a href="https://www.python.org/">Python</a>, <a href="https://nodejs.org/en/">NodeJS</a> and <a href="https://golang.org/">Golang</a>. This was great in general, but became a nightmare when writing shared libraries, since the same code had to be implemented in three different languages.</p><p>I do believe in experimenting with different tools, but we ended up treating everything as production-ready and long-lived. If you’re writing internal shared libraries, the services using them are no longer an experiment.</p><p>I’ve had to come to terms with settling down with a single language. It turns out that’s totally OK. Experiment as much as possible, but having a primary stack which is repeatable and consistent is valuable too. This is even more true if your services all operate under the same umbrella (e.g., web server with database connection).</p><h3>Ignored advice #4: Everything is a trade-off</h3><p>It turns out that a microservice architecture has a <strong>lot</strong> of downsides. I won’t go into them here (others have <a href="https://martinfowler.com/articles/microservice-trade-offs.html">already done that</a>), but I think it’s important to understand what you are signing up for.</p><p>If we had sat down and looked into the pros and cons, we would probably have found that it would only start being worth it as we grew into multiple backend teams, using different software to solve different problems.</p><figure><img alt="A graph representing the pros and cons of microservices" src="https://cdn-images-1.medium.com/max/1024/1*hexYwbzjagtjeA6EhcpB9Q.png" /><figcaption>The journey to net-positive value</figcaption></figure><h3>The punishment</h3><p>We’ve spent time and effort going back the way we came. In January 2019, we took a step back and looked for the biggest knot in our architecture. We identified ten services which were coupled so tightly that bumping a single one would collapse them all like a house of cards. We have since merged all ten to be a single service, and haven’t looked back.</p><p>We’ve also slowly phased out our Python services, and all but one of our Golang services. In some cases this has meant literal rewrites into NodeJS. We’re left with a single set of shared JavaScript libraries to maintain.</p><h3>Learnings</h3><p>If I could go back in time and give myself some warnings, I would say the following:</p><ul><li>Design for the problems you know you have, and be very meticulous when guessing about the future.</li><li>It’s safer to start with a few larger services and carve them up as the boundaries reveal themselves. A good rule of thumb is that one microservice is better than two unless you can articulate the reason for splitting them. Of course, there <em>are</em> many valid reasons, but make sure you know how they apply before going ahead.</li><li>When experimenting and building MVP services, be very clear about what you <em>won’t</em> do and stick to that. It’s easy to get trapped into maintaining something which isn’t the right solution.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c8b5dbdd58b8" width="1" height="1" alt=""><hr><p><a href="https://itnext.io/microservices-c8b5dbdd58b8">Learning the hard way: Microservices</a> was originally published in <a href="https://itnext.io/">ITNEXT</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A rant about alt+tab in elementary OS]]></title>
            <link>https://medium.com/@andrewvr/a-rant-about-alt-tab-in-elementary-os-b73754791ea8?source=rss-67b3c62ddae7------2</link>
            <guid isPermaLink="false">https://medium.com/p/b73754791ea8</guid>
            <category><![CDATA[design]]></category>
            <category><![CDATA[elementary-os]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[desktop-environments]]></category>
            <category><![CDATA[productivity]]></category>
            <dc:creator><![CDATA[Andrew van Rooyen]]></dc:creator>
            <pubDate>Thu, 29 Jun 2017 14:00:16 GMT</pubDate>
            <atom:updated>2017-06-30T05:48:41.617Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nodEC7GNOw_7ruYPn9XiCw.png" /></figure><p><strong>Disclaimer: </strong>I have been using elementary OS for a while now. It’s mostly great, but the alt+tab functionality really gets under my skin. My level of frustration has been enough to send me Googling for ways to change the default behavior, but not enough to actually do anything constructive about it. I suppose this should end up as a <a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Aopen+is%3Aissue+user%3Aelementary+label%3A%22Needs+Design%22">“Needs design” issue</a>, but at the time of this post I happened to feel like ranting, so I did that instead. Below is that rant — you have been warned. It details some specifics about why I think alt+tab in elementary OS is broken.</p><h3>The search for a fix</h3><p>First of all, there are plenty of complaints about this. There didn’t seem to be any solutions on the discussions I found, but what really disappointed me was that in many of those threads, the responses are really defensive — comments like “I don’t really know why you would want something other than what we have now”.</p><p>Seriously? From my perspective, alt+tab switching is hands down the worst part of elementary OS. It frustrates me <em>literally</em> every time I use it. I’d say that from a UX standpoint, it breaks continuity in more than one big way.</p><p>For reference, below is a short video of me switching through a typical set of open windows.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2Fta7itUYlLvk%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3Dta7itUYlLvk&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2Fta7itUYlLvk%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/502d3d3fa192e4bb3cd106d3703c854f/href">https://medium.com/media/502d3d3fa192e4bb3cd106d3703c854f/href</a></iframe><h3>The dock in general</h3><p>I appreciate the idea of overloading the dock, and I think it could work, but It needs more design. Plank only shows you the currently open apps while alt-tabbing, and this can be really jarring if the number of apps you have open is very different from the number you have pinned.</p><p>In the extreme case, when you alt+tab your “dock” suddenly looks very different — so much so that it takes my brain a split second to register it as “my dock”. This is confusing because although the two different modes provide completely different functionality, they look <em>kind of</em> the same. I mean this in the sense that they are both in the same area of the screen and have the same background, but show a different list of apps and have different widths. The change in width is the real culprit for me here — I have many apps pinned, so if I only have three or four apps open, hitting alt+tab makes my dock do a vanishing act. This confusion is compounded by the fact that I auto-hide my dock.</p><p>If it was my choice, I would either stop overloading the dock or make it work more like the current alt+esc functionality (except of course it would cycle through all apps instead of the most recent two).</p><h3>The window fly-in/out animations</h3><p>I like animations which are applied tastefully and don’t get in the way. But let’s look at what the alt tab switcher is supposed to do…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Rtttbz81Y8B8vV5LRuAcag.png" /><figcaption>Window overview via super+a</figcaption></figure><p>In my opinion, alt+tab should be a quicker version of the window overview/expose/super+a. I should be able to get a quick, general overview of how many things I have open, and at a glance be able to tell how many times I should tap tab in order to get to the one I want. If the number of open apps is small enough, the first time I cycle through them should provide me with a mental model of their order, so next time I know how many times to cycle without even having to see the list.</p><p>Having an animation as grand as the current one breaks any mental model that I have in my head. It’s generally disorienting, and worse, the chosen animation makes it look like the apps are moving (coming and going from the center of the screen) as you cycle. I don’t want to have to do extra work by trying to mentally block out the animation in order to keep my mental model consistent.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JcP3x1vbV_5JjJHghM7_jw.jpeg" /></figure><p>I know it’s for a different operation, but a good example of how to to this properly is the minimize/maximize animation in the macOS dock.</p><p>They use an animation that goes out of its way to map how the app fits into the bigger picture.</p><p>The fly-in/out animation on elementary OS does literally the opposite — it provides no actual value, and just adds more cognitive load.</p><h3>Multi monitor</h3><p>This one is really simple.</p><p><strong>A)</strong> Plank on elementary defaults to having one dock — on the main screen</p><p><strong>B)</strong> Plank is used as the alt+tab switcher</p><p>I don’t disagree with either of these choices, but they can’t be used together. Pick one and move on from there.</p><p>I primarily use two screens. It takes mental load to go through the cycle:</p><ul><li>hit alt+tab</li><li>get confused</li><li>lose my train of thought while trying to grok my screen</li><li>remember how it works</li><li>move away from where I was working to look at the bottom of the main screen</li><li>etc.</li></ul><h3>Smaller things</h3><p>As far as I know, there’s no equivalent of alt+` from other desktops. It would be cool if I could cycle between windows of the same app, on multiple screens, etc. Not really a deal breaker though.</p><p>Also, alt+tab with one window open makes the screen flash.</p><p>/rant</p><h3>P.S.</h3><p>Here are some resources if anyone is interested.</p><ul><li><a href="https://github.com/tom95/gala-alternate-alt-tab">https://github.com/tom95/gala-alternate-alt-tab</a></li><li><a href="https://code.launchpad.net/~gala-dev/gala/no-depth-alt-tab">https://code.launchpad.net/~gala-dev/gala/no-depth-alt-tab</a></li></ul><p>Both of these were last updated two years ago. I didn’t actually try either, so if anyone has had a positive experience with them in Loki I’d be interested to know.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b73754791ea8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Agent Resources in GoCD]]></title>
            <link>https://medium.com/@andrewvr/agent-resources-in-gocd-37279170acdd?source=rss-67b3c62ddae7------2</link>
            <guid isPermaLink="false">https://medium.com/p/37279170acdd</guid>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[gocd]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Andrew van Rooyen]]></dc:creator>
            <pubDate>Wed, 15 Feb 2017 19:40:58 GMT</pubDate>
            <atom:updated>2017-02-16T14:23:24.372Z</atom:updated>
            <content:encoded><![CDATA[<p>Lately I’ve been working with <a href="https://go.cd/">GoCD</a>. It’s an open source continuous integration tool which has both driven me crazy and blown my mind in countless ways over the past 8 months or so. It isn’t as well-known as Jenkins or Travis, but some of its core principles are fundamentally different to (and in my opinion, better than) any other CI tool I’m aware of.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/788/0*ihzcUoR74p2gLJWO.png" /><figcaption><em>Google searches for popular CI tools</em></figcaption></figure><p>The graph above paints a pretty accurate picture of this space. A few years ago, everyone (including us) was using Jenkins. There has been some effort to improve Jenkins (e.g. by adding a plugin for pipelines), but it has pretty much been succeeded by Travis. Circle CI is also proving to be a dominant force, and seems to be the service which is attracting all the cool kids.</p><p>Having moved to GoCD, I don’t regret the decision. Even though there are at least 4 other tools which are more popular, I’m a firm believer in GoCD’s vision of pipelines as a first-class citizen. While it still lacks in some areas like the UI, these are being actively worked on. The project is still young, and major new features are still being added in the monthly releases.</p><h3>Agents and Resources</h3><p>GoCD operates with one server node and multiple worker nodes. The central server hosts the web interface and keeps track of pipelines and artifacts. Workers check in on a specific port, and ask for jobs to run. If you’re thinking that this sounds like a cluster management system, you’re right! In fact, we use the Docker containers provided by the GoCD team, and there has even been some initial work done on <a href="https://plugin-api.go.cd/current/elastic-agents/">elastic agents</a>.</p><p>This approach isn’t unique to GoCD, but the tool does go a bit further with <strong>agent resources</strong>. Basically, each job can be tagged with things like python3-dev, windows or libcurl. While being just text, they can be extremely powerful. The server will only give a job to an agent if that agent also has those tags. Here’s an animation to demonstrate.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*JrOrDUoHyBO8RoyqdIbLYw.gif" /><figcaption><em>A master/worker CI system with two different types of workers</em></figcaption></figure><p>The white block in the lower right is the server node. The blue and purple blocks are agents with two different tags.</p><p>During a recent refactor of our CI system, I took the opportunity to redefine how these tags were set up, and what was installed on our agents. This was sorely needed because when we initially set our agents up, we had only just begun to play with Docker. We had two different agents which were both overly complicated, had large Dockerfiles and took hours to build. So I decided to hop over to the opposite end of the spectrum. I was going to adopt the microservice philosophy and build many agents, all of which performed one very specific function and therefore had small, easily manageable Dockerfiles.</p><blockquote>These ‘micro-agents’ were going to be <em>amazing</em>.</blockquote><h3>What I learned</h3><p>This scheme worked great for a while. I had agents for various languages, one that knew how to build Docker images, one that knew how to deploy to Google Cloud Platform, one that could build our documentation and more…</p><p>Then I came across a situation where I needed to build the documentation and deploy it in the same unit of work. This was impossible, because no one agent could do both tasks. While you generally want to split up building and deploying, sometimes it just doesn’t make sense. GoCD is quite particular about what pipelines/stages/jobs should be, and swimming against that current is a <em>very</em> bad idea. I know this from experience, so rewriting my pipelines by splitting jobs up wasn’t an option.</p><p>It became clear that there’s a trade-off. You either get manageable agents or sane pipelines. Not both.</p><p>Going forward, I will always recommend that the pipelines configuration comes first. Design them without thinking about agents, and work backwards from there. Afterwards, if there are groups of jobs which are clearly mutually exclusive, then create an agent type for each one. Even with this approach, you might find that there are a few things which <em>all</em> agents need. Docker’s layers can help you out here, because you can define a general ‘base agent’ which the other types build off.</p><p>Here’s a diagram of the agents that I ended up with.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Gvt2Ji9zmnWSVnaQ.png" /><figcaption><em>Separation of concern for Docker-based worker agents</em></figcaption></figure><h3>P.S.</h3><p>GoCD also has a concept of ‘environments’, which function similarly to resources. I did try to make use of the feature, but it didn’t quite suit my use case.</p><h3>More resources</h3><p>Trends for CI tools — <a href="https://www.google.com/trends/explore?date=2008-01-01%202016-11-15&amp;q=GoCD,Jenkins%20CI,Travis%20CI,Circle%20CI,Codeship">google trends</a><br>How Dockerfiles work with layers — <a href="https://docs.docker.com/engine/userguide/storagedriver/imagesandcontainers/">docker docs</a><br>GoCD Docker images — <a href="https://hub.docker.com/u/gocd/">dockerhub</a> | <a href="https://github.com/gocd/gocd-docker">github</a><br>GoCD elastic agents — <a href="https://plugin-api.go.cd/current/elastic-agents/">beta docs</a><br>Resources, jobs, stages and pipelines in GoCD — <a href="https://docs.go.cd/current/introduction/concepts_in_go.html">gocd concepts</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=37279170acdd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Desktop environments]]></title>
            <link>https://medium.com/@andrewvr/desktop-environments-5789fdafcad6?source=rss-67b3c62ddae7------2</link>
            <guid isPermaLink="false">https://medium.com/p/5789fdafcad6</guid>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[ubuntu]]></category>
            <category><![CDATA[elementary-os]]></category>
            <dc:creator><![CDATA[Andrew van Rooyen]]></dc:creator>
            <pubDate>Wed, 15 Feb 2017 19:34:31 GMT</pubDate>
            <atom:updated>2020-04-12T13:05:48.727Z</atom:updated>
            <content:encoded><![CDATA[<p>If you spend 8+ hours a day working in a particular space, it’s pretty important that it’s comfortable and allows you to be productive. If you spend a lot of time driving with your seat too close to the wheel, your back will start hurting. If your office is filled with with crappy stationary, you’ll end up frustrated with pens containing gravity-defying ink and staplers which are only good for making holes in paper.</p><p>This sounds pretty dumb, right? Just move the seat back. Buy better stationary. These examples are trivial and can be fixed with almost no effort. The thing is, computer interfaces are just as important but users often settle for the default option, even when there are alternatives.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*iu3NNuf0zyjB8Ukn.png" /><figcaption><em>Desktops can be both functional and elegant<br>Credit to </em><a href="https://reddit.com/user/robowarrior_/"><em>/u/robowarrior_</em></a></figcaption></figure><p>Let me digress a bit, and explain what I mean by “Desktop environment”. The <a href="https://en.wikipedia.org/wiki/Desktop_environment">Wikipedia article</a> talks about the icon, window and toolbar metaphors (although you might not want to read too closely or you’ll find <a href="https://en.wikipedia.org/wiki/WIMP_(computing)">this</a> page).</p><p>To me, a good DE is defined by <strong>workflows</strong> rather than specific elements.</p><p>It should have the following.</p><ul><li>The ability to launch apps with minimal friction</li><li>Window management that doesn’t get overwhelming as I open an increasing number of apps</li><li>An area to represent background apps which don’t always have their own window</li><li>A way to group windows into separate workspaces</li><li>A notification system which gets my attention without being irritating</li><li>Controls and feedback for volume, brightness etc.</li><li>The ability to tuck itself away, giving complete focus to the app I’m working on</li></ul><p>Personally, I have tried a fair number Linux desktop environments over the years, including <a href="https://www.kde.org/">KDE</a>, <a href="https://github.com/linuxmint/Cinnamon">Cinnamon</a>, <a href="http://unity.ubuntu.com/about">Unity</a>, Elementary OS’ <a href="https://en.wikipedia.org/wiki/Elementary_OS">Pantheon</a>, <a href="https://www.gnome.org/gnome-3/">Gnome 3</a>and <a href="https://i3wm.org/">i3wm</a>. I’ve even experimented with <a href="http://litestep.info/">LiteStep</a>, an alternative to explorer.exe on Windows.</p><p>As is often the case with software, all of the above had elements that I was really impressed with, but equally had failings which made me move on. I’ll mention some thoughts on three that stood out to me.</p><h3>Pantheon desktop</h3><p>Elementary OS uses an app launcher called <em>Slingshot</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/819/0*ZEZZwmAKipnaZQv8.png" /><figcaption><em>Slingshot launcher</em></figcaption></figure><p>It’s simple, fast, and fits my use case exactly. If I want to open Chrome, all I need to do is hit SuperchrEnter. No need to involve the mouse or remember the full name of the binary. Even though most launchers (including the Windows Start Menu) work like this these days, Slingshot <em>just works</em>, and looks elegant in the process.</p><h3>Unity</h3><p>Ubuntu’s default desktop environment has a pleasantly minimal status bar. It lends itself to the style that macOS has gone with, which I think is a good thing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8VF99CNvdPADr2BT.png" /><figcaption>Unity</figcaption></figure><p>Some people don’t like that it also acts as a menu bar (File, Edit, etc.), but I think that it helps with keeping everything consistent. That said, there is one corner case that I encounter quite often: If I’m looking at a particular window, but for some reason have a different one selected, it can be disorientating to get a different set of menu bar options to what I’m expecting. I don’t have a good solution to this, but it’s still irritating. Either way, this style is optional in Ubuntu 16.04 and later.</p><h3>i3</h3><p>An honourable mention for window management goes to i3wm. Being a tiling window manager, it’s kind of in a different league to everything else I’ve worked with, and it definitely has it’s place. Its basic philosophy guarantees an extremely efficient workflow, which I admire. Unfortunately, I found myself trying to force it to be a full desktop environment, which is was never meant to be. This included code in my i3 config like the following:</p><pre>bindsym XF86MonBrightnessUp exec &quot;xbacklight -inc 5; killall notify-osd; notify-send &#39;Backlight&#39; `xbacklight`&quot;<br>bindsym XF86MonBrightnessDown exec &quot;xbacklight -dec 5; killall notify-osd; notify-send &#39;Backlight&#39; `xbacklight`&quot;</pre><p>This attempts to add brightness controls via the function keys on my laptop, and give feedback via a notification pop-up. What I learned:</p><ul><li>Most implementations of notify-send suck. Especially Ubuntu’s</li><li>i3wm is not a full desktop environment, no matter how badly you want it to be</li></ul><p>Some days, I feel kind of bad for not using something like i3wm. My inner hacker tries to convince me that I’m a sellout, but honestly, I firmly believe that I shouldn’t have to compromise on aesthetics and conveniences like pretty volume sliders. I should be able to have both. Sorry, i3wm.</p><h3>So what do I use?</h3><p>At the time of this post, I’m using Unity. Not because I think it’s amazing, but because it has the least drawbacks. It has a fairly good perspective on the workflows that I care about, and has sane defaults. I only change two things on a fresh install. First, I set up a combination of the <a href="https://numixproject.org/">Numix</a> theme and the <a href="https://snwh.org/paper">Paper</a> icon set. Then, I disable ‘scopes’ that I don’t care about like so:</p><pre>dconf write /com/canonical/unity/dash/scopes &quot;[&#39;home.scope&#39;, &#39;applications.scope&#39;, &#39;files.scope&#39;]&quot;</pre><p>This reduces clutter in the app launcher and allows me to use key combinations like Super+c to open Chrome (instead of the ‘Photos’ scope).</p><h3>Final thoughts</h3><p>I think that what software you use isn’t particularly important, as long as it works well for you. The catch is that it’s important to know what’s out there. This means being willing to do research and leave your comfort zone to experiment. Also, not having a Linux setup doesn’t mean that you don’t have options; workflows can be improved with simple apps like a clipboard manager, or something like <a href="https://www.alfredapp.com/">Alfred</a> for macOS. You’ll find what works for you — just don’t stop trying to make your environment better.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5789fdafcad6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Notes to myself]]></title>
            <link>https://medium.com/@andrewvr/notes-to-myself-75ff1dadc1bd?source=rss-67b3c62ddae7------2</link>
            <guid isPermaLink="false">https://medium.com/p/75ff1dadc1bd</guid>
            <dc:creator><![CDATA[Andrew van Rooyen]]></dc:creator>
            <pubDate>Wed, 15 Feb 2017 19:32:14 GMT</pubDate>
            <atom:updated>2017-02-15T19:32:14.215Z</atom:updated>
            <content:encoded><![CDATA[<p>I have never been the kind of person who actively posts on social media. In fact, if you were to look through my Facebook/Twitter timelines right now, you would find a bursting collection of “not much”.</p><p>This is just <em>who I am</em>. I have always preferred to consume writing rather than generate it. I spend a healthy amount of time reading books, and an unhealthy amount of time sifting through Hacker News and Reddit. So, starting a “blog” is certainly unusual for me.</p><h3>Then why?</h3><p>Recently, I’ve found myself thinking about something specific, and wanting to record it somewhere. Not for other people to read, but rather to help get my thoughts in order and maintain an archive, in case I need to come back to that train of thought in the future. At first I looked into note-taking tools like Evernote, but ended up leaning towards keeping my own set of markdown files. That became a Jekyll blog hosted with Github ages, which in turn led me here. I see this as an opportunity for me to organize my thoughts, and take stock of lessons I’ve learned in an open way. If people read what I post — great. If they don’t — at least I will.</p><p>I don’t have a particular plan for what I’ll be writing, but it will likely involve</p><ul><li><strong>Programming environments</strong> — Mostly Vim, but also general workflows inside a terminal</li><li><strong>Tooling around programming for the cloud</strong> — Specifically CI/CD, Docker and Google Cloud Platform</li></ul><p>There will be code snippets. There will be diagrams. There will be opinions.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=75ff1dadc1bd" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>