Matt Oswalt

Copy and Clone in Rust

Thu, 28 Dec 2023 10:00:00 +0000

Rust’s Copy trait is one of the earliest things I struggled with when I started learning the language. On its surface, this trait is quite simple, but its implications on how an implementing type can interact with Rust’s ownership model are significant. As I gained more experience, I also encountered the Clone trait frequently as well, and like many others, found it difficult to remember the differences between the two, especially early on. Both are just two of several examples of how Rust is much more explicit about these kinds of things, especially when compared to the languages I’ve historically used.

Network Programmability and Automation: Second Edition

Fri, 08 Jul 2022 10:00:00 +0000

Nearly seven years ago, I wrote a blog post announcing an exciting new project: a new O’Reilly book titled “Network Programmability and Automation”. Of course, I was absolutely thrilled to work on this project with my co-authors Jason Edelman and Scott Lowe, but I was also eager to be able to make this kind of impact on what was still at the time, a very nascent network automation discipline in the industry.

Non-Local Address Binds in Linux

Thu, 24 Feb 2022 00:00:00 +0000

I came across some interesting sockets-related behavior this week that caused me to go down a bit of a rabbit hole. This ended up taking me on a tour of Linux’s socket and IPv4/IPv6 implementation. I thought the journey was instructive, and I hope that my attempt to recount the steps I went through is useful to you.

Shifting Gears

Mon, 10 Jan 2022 00:00:00 +0000

My career path has been anything but linear. I’ve tried a little bit of everything - in fact, the last few years of my career were aimed at accomplishing just that. It’s all been consistently technical, but this manifested in a wide range of different roles, ranging from operations to product. But now it’s time for a new challenge, and a more deliberate focus on becoming a better engineer.

The Evolving eBPF Toolchain

Thu, 01 Jul 2021 00:00:00 +0000

These days there is an ever-growing list of tools and frameworks for working with eBPF, all at varying levels of abstraction. There does seem to be a few that sit at the core of the rest of the eBPF ecosystem. However, the ecosystem is changing rapidly, and I’ve found it to be a bit difficult to navigate through the sea of information that’s out there and understand which tools are the current “standard” for each use case, and which are being deprecated/changed. If you’re not totally plugged in to the linux kernel community, it may not be obvious where to start.

Polymorphism in Rust

Tue, 22 Jun 2021 00:00:00 +0000

In the previous post we explored the use of generic types in Rust and some of the common reasons for doing so. In this post, I’d like to take a step back and look at the full spectrum of options Rust makes available for accomplishing polymorphism, and get under the covers so we fully understand the tradeoffs of the decisions we make as Rust developers.

Using Generic Types in Rust

Tue, 15 Jun 2021 00:00:00 +0000

In a prior post, I explored “generic programming” with the aim of highlighting the language-agnostic benefits and core concepts. Especially if this is a new topic for you, I encourage you to read this post first, as there are a lot of ideas covered there that apply much more broadly than what we’ll get to in this post, which instead will focus on how Rust does things.

Introduction to eBPF

Tue, 19 Jan 2021 00:00:00 +0000

If you’re paying much attention at all to the systems or cloud-native communities, you have certainly heard about eBPF. It has dominated several conference schedules for the last few years, and it even has its own conference now! However, unlike a lot of hyped-up technology buzzwords, this one’s momentum doesn’t seem to be unwarranted, or even ahead of the curve:

What Are Data Types Anyways?

Thu, 19 Nov 2020 00:00:00 +0000

There are actually quite a few resources out there for a novice programmer to learn about data types like strings, integers, floats, and more. The wikipedia page, as an example, covers a broad spectrum of potential meanings. Just about any book or tutorial focused on a particular programming language will start off by listing the types supported by that language. This makes sense, since they are the fundamental building block of being able to do pretty much anything in that language. What’s more is that once you’ve learned the types in one language, the vast majority will also be supported in any other language, with worst case being a slightly different name or syntax.

Anatomy of a Binary Executable

Wed, 04 Nov 2020 00:00:00 +0000

Even though I’ve developed software for a number of years now, there’s one question that has always been in the back of my mind and I haven’t had the time or patience to really answer, until now: What is a binary executable anyways?