Posts on Systems++

Using my iPad as a Second Monitor with KDE Plasma

Thu, 30 Oct 2025 10:58:14 -0500

When traveling it is sometimes helpful to have access to a second monitor. An iPad does a passable job for this when your traveling and just need a little more screen real-estate.

Installing My Server Fully Remotely

Thu, 23 Nov 2023 12:17:00 -0500

I run a small tower server in my house to provide services that I use for software development, recently CentOS-8-Stream reached end of life. Since this server distribution doesn’t support in-place updates, updating requires reinstalling with a new version of the CentOS-9-Stream. This post documents the challenges that I hit along the way.

Dethroning LaTeX: What Would It Take?

Sun, 02 Jul 2023 00:00:00 +0000

As an academic, you write a lot of papers. If you contribute to the disciplines of Math, Computer Science, or some domains of physical sciences, you’ve probably used LaTeX – a typesetting language – through a tool like Overleaf. What’s nice about LaTeX is that it attempts to separate concerns: Authors with minimal effort can port the text and structure of a document from one style to another. It generally produces much more ascetically pleasing output by default than what most authors would do on their own. It handles formatting of three things that generally are extremely frustrating in other tools: citations/bibliography, cross-references, footnotes/endnotes, equations, and embedded code listings. When used with a source control like Git it provides one of the best change review and tracking mechanisms of any document platform.

How I Work: Killer Libraries

Mon, 24 Apr 2023 00:00:00 +0000

Most successful langauges have a “killer” features that motivates

In my previous post, I commented on the tools that I use for software development, but I didn’t talk about either the process of choosing a language or the libraries within a language that I use most frequently. This post expands on how I work within a language and specific “killer” libraries that I use most and how they compare to facililties that I know from other languages.

Refactoring CI/CD for a Moderately Large C++ Code Base

Mon, 24 Apr 2023 00:00:00 +0000

CI/CD is a critical, but difficult to get right part of software engineering. You often want to test multiple distributions, multiple compilers on each commit, and you want that to be as fast as reasonably possible. This gets more complicated when you have large dependency trees that you want to remain consistent. Recently, I adapted the CI/CD system for a project that I maintain LibPressio to use Dagger – a programmatic way to do CI/CD portable-ally across runner environments which made it easier to run our tests and verify correctness.

How I work: The Tools I Use

Tue, 14 Mar 2023 00:00:00 +0000

From time to time I get a question of what tools I use for what jobs. Here the tools I use to get things done:

External Clang-Tidy Modules! C++ Refactoring for the Common Project

Fri, 10 Mar 2023 00:00:00 +0000

Clang style refactoring has been something I’ve been admiring from afar for quite a while now. However for a user to actually use it, it has previously required forking llvm to be able to use it in a reasonable fashion because of things like the hack in clang used to locate the resource directory or other fragile hacks like LD_PRELOAD.

Refactoring With Clang Query

Wed, 28 Dec 2022 00:00:00 +0000

Have you ever wanted to identify a list of files that would need modifications to adopt a new API? Clang-Query can make this much easier. I recently wanted to introduce a set of helper functions to simplfy an aspect of compressor configuation in LibPressio. But first, I needed to know what modules were effected.

Three Neat Things I Did With Julia

Thu, 15 Dec 2022 00:00:00 +0000

In the past, I’ve written pretty glowingly about Julia. It’s been a few years since I first used Julia in 2019, and it hasn’t completely replaced Python for me. However, I wanted to share a few neat projects that I’ve done using it which would have been much more painful without it, and share what I think now about what I wrote in 2019.

Debugging Inconsistent Network Performance

Wed, 14 Dec 2022 00:00:00 +0000

High-performance network interconnects, such as Infiniband, are common in high performance computing environments. Recently, my colleagues, and I ran a series of experiments on the Cooley system at the Argonne Leadership Computing Facility. For one set of experiments, the network performance was consistent and fast, but for the others we periodically had poor performance. Up until this point in my work, I had not directly used or configured network libraries below this layer. This post summarizes the steps we took to investigate the performance.

Thoughts on Dependencies for Scientific Software

Wed, 20 Jul 2022 00:00:00 -0500

Modern software does not exist in a vacuum, developers always rely on other developers or engineers to provide aspects of their systems. Even if you write hello world in your programming language of your choice you likely still depend on the standard library from your language. Even if you were to write hello world in the raw binary format of your assembly language, you still depend on the operating system. Even if you wrote your own uni-kernel to produce hello world on the console, you likely rely on vendor provided firmware to initialize the program or memory. And if you are one of the blessed few who can completely fabricate your own hardware and don’t need to rely on vendor provided firmware, you likely don’t have time or expertise to write efficient higher level systems and need others to provide software to run on your hardware. Therefore the question is not will you use dependencies, but how will you use them responsibly.

Spack: a Truly Useful Package Manager

Thu, 27 Aug 2020 08:00:00 -0500

So you are developing software, and you need the software to build for multiple difference machines, with different version of a library, or with just different compile time options. You can probably manage this by hand, but it very quickly gets out of hand. Spack is a package manager designed for high performance computing, but I would argue is more broadly useful for five reasons:

Strong or Robust?

Sun, 17 Nov 2019 08:00:00 -0500

Should a software design be strong or robust? This is a debate that seems to have been developing in recent years with the recent proponents so-called “strong-typing” advocating new API designs. In this post, I go a little into the debate and discuss its consequences.

Julia: Could There be One Language?

Thu, 04 Apr 2019 09:00:00 -0500

There is a constant problem with programming language design: fast, generic, easy to write; pick two. The principle is that programming languages cannot be all three at once. Code that is Fast and Generic like C++ isn’t exactly easy to write. Code that is Generic and easy to write like Python isn’t always fast in the sense that C/C++ programmers mean it. Code that is Fast and Easy to Write isn’t always Generic in the sense that Python is. There is a new language on the block – Julia – which strives to challenge these assumptions. In the remainder of this post, I highlight what I like about it and describe my experience using it over the last semester.

Configuration Management: Common Pitfalls

Tue, 31 Jul 2018 10:00:00 -0500

So you know you need a configuration management system and you have an idea of which one will work for you. So what should I think about about before deploying one of this systems? In this third and final post in this series, I present some suggestions about using these systems in a way that is flexible and scalable to larger numbers of systems.

Configuration Management: the Battle Royal

Tue, 31 Jul 2018 09:00:00 -0500

So, you need a Configuration Management System, so which one do you choose? This post is the second in a three part series on configuration management. In this post, I’ll highlight the strengths of these systems and their respective weaknesses.

Configuration Management: the Related Systems

Tue, 31 Jul 2018 08:00:00 -0500

Configuration Management Systems like Ansible, Chef, Puppet, and SaltStack are in my opinion are nearly essential if you find yourself managing more than 5 machines. But what exactly are they, which is better for my circumstances, do I still need them if I use a container based infrastructure, how do I get started? This post is the first in a series of posts that will attempt to answer these questions.

Generic Cuda

Sat, 12 May 2018 08:00:14 -0500

GPU programming has the potential to make embarrassingly parallel tasks very quick. But what if you want to perform the same task on a variety of different types? In this post, I walk through a generic testing code that preforms a vector add on GPU and CPU to verify the correctness.

Life with Libtooling

Sun, 10 Dec 2017 11:21:00 -0500

Over the last two months, I spent a significant amount of time using Clang’s libtooling. Libtooling is a great way to quickly develop tools to analyze and modify large quantizes of C++. In this article, I share some lessons learned working with libtooling.

Design of A Matrix loading Library

Sat, 23 Sep 2017 07:00:00 -0500

Ever notice that every matrix and graph library seems to have a different interface for constructing matrices? Also notice that each only only supports some subset of common matrix formats? With a little help from the Adapter and Builder design patterns we can actually solve this problem.

Qt is for more than just GUIs

Tue, 23 May 2017 10:58:14 -0500

When most people think of Qt, I imagine that they think about the Graphical User Interface components. But Qt has a variety of other components beyond just being a GUI framework. In this post, I highlight some of what I find to be the more interesting features.

Pluggable Authentication With PAM

Sun, 14 May 2017 10:58:14 -0500

Authentication and authorization is one of foundational aspects of any security system. However writing an authentication and authorization system can be anything but: There are complex, ever-changing requirements, not to mention differences for differing interfaces it can quickly become daunting. However, there already exists a system on Linux and Unix that allows for dynamic and complex authentication: PAM.

Resource Acquisition is Initialization and SDL

Mon, 08 May 2017 05:30:14 -0500

Recently, I was working on a project for 2D Game Development where I had to use SDL 2.0. SDL 2.0 is a family of media libraries designed for writing cross platform games in C. However it can be difficult to remember where various resources are allocated and deallocated. Resource Acquisition is Initialization (RAII) is a common pattern in C++ programming that solves this problem. So I wrote a series of wrappers for SDL 2.0 that use RAII and various other improvements.

Smart Pool

Sun, 30 Apr 2017 09:58:14 -0500

Object Pools are a commonly used pattern used in operating systems, game, and high performance computing development. However just as it can be easy to forget to return a pointer to memory, it can be easy to forget to return the memory to the pool. In this article, I layout a class that I recently used to automatically manage memory from a pool.

Surprisingly Functional

Thu, 23 Feb 2017 08:38:14 -0500

Functional programming is a surprisingly useful programming paradigm. The best aspects of functional programming have this odd habit of showing in places you would never expect.

Faster than light

Sun, 29 Jan 2017 10:06:14 -0500

Ansible is probably my favorite provisioning and configuration management tool. Its syntax is concise, expressive, and elegant. Unlike other tools in its category, it has excellent documentation with working examples and intuitive naming. Learning it use it effectively can help you be a more productive developer.

LLVM Tooling for C++

Sun, 22 Jan 2017 18:58:14 -0500

C++ is a both a fantastic language and a mess. It supports at least 4 programming paradigms (procedural, functional, object-oriented, template meta-programming). In some senses, many languages give you one great way to do things: C++ gives you every way and trusts you to use them well. With this flexibility comes problems that C++ seems to have beyond what other languages experience. Therefore, having effective tooling to develop and use C++ is essential.

Interpreters Made Easy

Sun, 15 Jan 2017 10:14:14 -0500

The Interpreter pattern from the “Design Patterns: Elements of Reusable Object Oriented Software” can potentially be a very powerful pattern. It allows you to use a domain specific language to represent a complex computational situation. However, writing interpreters in practice can be tricky and time consuming. It really helps to know something about some fundamental parsing algorithms and techniques.

Poor Man's Parallelism

Sun, 08 Jan 2017 10:58:14 -0500

I really like orchestration tools such as Ansible or SaltStack. They can make running tasks on a group of machines a breeze. But sometimes you can’t or don’t want to install these tools on a machine. In cases like these, it is helpful to know how to parallelize some tasks in the shell.