Colin Breck

Making Unsafe Rust a Little Safer: Tools for Verifying Unsafe Code, Including Libraries in C and C++

This article will look at tools for verifying unsafe Rust code, including unsafe code called from libraries written in C or C++.

Predicting the Future of Distributed Systems

There are significant changes happening in distributed systems.

Administrivia: Reconsidering the Engineering and Management Tracks

Multiply your best engineers by unburdening them from administrative work.

Is the Scientific Method Valuable in Engineering?

In engineering, fixating on a hypothesis, and working to confirm or falsify it, can lead us astray.

Future Software Should Be Memory Safe: Reflections on A Path Toward Secure and Measurable Software

Future software should be memory safe, but secure code is about a lot more than memory safety.

Object Storage and In-Process Databases are Changing Distributed Systems

The cloud will become increasingly less important for transactional and analytical data processing and storage.

An Interview Process That Works For Me

“What is your interview process?” is a question I have answered many times. I have conducted technical interviews for over twenty years and I am proud of the process I have refined in the past decade. It has been extremely effective for hiring high-quality software engineers that are a fit

Choosing a WebAssembly Run-Time

The security of the platform is critically dependent on the quality of the WebAssembly run-time that implements the sandbox.

WebAssembly at the IoT Edge: A Motivating Example

In a previous article, I shared my excitement for WebAssembly in the context of the Internet of Things (IoT). I am particularly excited about the potential for sharing code, flexibly and securely, between the cloud and the edge. In this article, I provide a motivating example.

Why Am I Excited About WebAssembly?

As it continues to evolve, WebAssembly has the potential to be the platform executing an enormous amount of IoT computation.

Our Transition to Renewable Energy: Motivating the Most Challenging Problems in Distributed Computing and IoT

With millions of points of control and a mix of cloud and edge computing, the renewable energy grid is a massive, distributed computing platform with unique challenges.

Cancer: A Twenty-Year Reflection

Twenty years ago, I was diagnosed with cancer.

Engineering Management: Three Books and Three Videos

I can distill my management philosophy to three accessible books, all of which have an accompanying video lecture.

Masking the Problem: Representing Complex State Without Strings

Maybe the industrial world had it right all along.

Version Too

A joke is not funny if you have to explain it, but this essay is my attempt to explain a joke.

Twitter: A Love-Hate Relationship

We need to look at the real world and not just re-presentations of it.

The State of the Art for IoT

Just because a device is connected to the Internet does not make it IoT.

Kubernetes Startup Probes: Getting Your Feet Under You

If you will allow me to continue my self-indulgent podiatric joke: startup probes allow you to get your feet underneath you.

Love

Thanks for being my understanding.

SARS-CoV-2 and the Future of Work

I will conclude with a call to action. If this blog goes quiet for a while after this, you will understand why.

Reflecting on Our Core Values

This is an essay about reflecting on our values to understand what drives them in order to separate our core values from these other strong drivers.

Understanding Our Core Values: An Exercise for Individuals and Teams

An exercise in exploring, identifying, expressing, and sharing our core values.

Shared-Nothing Architectures for Server Replication and Synchronization

A shared-nothing approach to server replication, notably one that incorporates a shared, distributed journal, is a far more reliable, flexible, and powerful approach, particularly for systems focused on time-series and events.

On Embracing Error in Distributed Software Systems

Guarantees do not compose into complex systems.

Rethinking Streaming Workloads with Akka Streams: Part III

Combining actors and streams can make problems simpler, with less code to test and maintain, and with a more natural separation of concerns.