Colin Breck

Previously, I wrote an essay [https://blog.colinbreck.com/kubernetes-liveness-and-readiness-probes-how-to-avoid-shooting-yourself-in-the-foot/] describing how Kubernetes liveness and readiness probes can unintentionally reduce service availability, or result in prolonged outages. In the conclusion of that essay, I highlighted Lorin's Conjecture [https://lorinhochstein.wordpress.com/2017/06/24/a-conjecture-on-why-reliable-systems-fail/] : > Once a system reaches a

This article expands on a keynote [https://www.youtube.com/watch?v=Ifaqjop1gzU] that I gave at Reactive Summit 2018. I also discussed these topics on the Real-World Architecture Panel [https://www.infoq.com/presentations/architectures-panel] at QCon San Francisco 2018. An operational technology combines hardware and software to monitor

Kubernetes liveness and readiness probes can be used to make a service more robust and more resilient, by reducing operational issues and improving the quality of service. However, if these probes are not implemented carefully, they can severely degrade the overall operation of a service, to a point where you

Services that incorporate streaming workloads often need to perform asynchronous requests to other services, or execute long-running, asynchronous operations. Examples include, inserting time-series data into a database, retrieving metadata for data enrichment, and executing complex business-workflows. Executing asynchronous operations in a streaming context, while maintaining backpressure in the stream, is

When I was in elementary and secondary school, I did not enjoy reading or writing. Both were a chore. This probably had a lot to do with the fact that the rote learning and clerical curriculum that is core to modern, institutional education, was just not right for me. I

You have probably had the experience of working tirelessly on a challenging, high-profile, business-critical project, for a significant period of time, chasing the satisfaction of completing the project successfully, only to have it be suddenly finished, completed with very little fanfare, or the gratifying catharsis that you were anticipating. You

I have never had an internship. In fact, while I was an undergraduate in university, I never even had a summer job related to engineering or software development. I worked at a living-history museum [https://www.forthenry.com/] for three summers, giving guided tours, performing artillery demonstrations, and playing bagpipes

I expand on these concepts in my Scale by the Bay presentation [https://www.youtube.com/watch?v=MzosGtjJdPg]. In an earlier article [https://blog.colinbreck.com/maximizing-throughput-for-akka-streams/], I detailed a number of techniques that can be used to maximize the throughput for individual Akka Streams. In a subsequent article

I expand on these concepts in my Scale by the Bay presentation [https://www.youtube.com/watch?v=MzosGtjJdPg]. In an earlier article [https://blog.colinbreck.com/maximizing-throughput-for-akka-streams/], I detailed a number of techniques that can be used to maximize the throughput for Akka Streams. The article focused on improving

This three-part series expands on a talk [https://www.youtube.com/watch?v=3APiIht6oDY] that I gave at a conference focused on time-series data in 2018. This three-part series is focused on the challenges of elevating a time-series database from being just an IT application, used in the data center,

This three-part series expands on a talk [https://www.youtube.com/watch?v=3APiIht6oDY] that I gave at a conference focused on time-series data in 2018. The first article [https://blog.colinbreck.com/from-a-time-series-database-to-a-key-operational-technology-for-the-enterprise-part-i/] in this series explored challenges related to time when elevating a time-series database from simply an

This three-part series expands on a talk [https://www.youtube.com/watch?v=3APiIht6oDY] that I gave at a conference focused on time-series data in 2018. Many people are familiar with using a time-series database for collecting metrics from servers, applications, databases, and services running in a data center. A

I expand on these concepts in my Scale by the Bay presentation [https://www.youtube.com/watch?v=MzosGtjJdPg]. The Akka Streams API is fantastic for building scalable applications that involve streaming workloads. It provides high-level semantics that naturally describe these workloads, and it handles the dynamics inherent to these

Dan Pink's Drive [http://www.danpink.com/books/drive/] is one of my favourite books. I also really like his RSA talk [https://www.youtube.com/watch?v=_mG-hhWL_ug] on the same subject. Pink argues that people are happy, engaged, productive, and creative when they are intrinsically motivated, as

I want to raise awareness of a simple mistake that can be made with the successful method of a Scala Future. A Future is a placeholder object for a value that may not yet exist. It is used for performing operations concurrently, in a non-blocking manner, and it enables scaling

I expand on these concepts in my Reactive Summit presentation [https://www.youtube.com/watch?v=qaiwalDyayA]. In the first article [https://blog.colinbreck.com/integrating-akka-streams-and-akka-actors-part-i/] of this series, I demonstrated the most basic patterns for integrating Akka Actors and the Akka Streams API. In the second article [https://blog.

When you work in engineering or operations, you become intimately familiar with the challenges of technical debt. It can be difficult, however, to communicate the full cost of technical debt to others in the organization, particularly to people who are non-technical. Communicating the latent risks for software systems that are

I expand on these concepts in my Reactive Summit presentation [https://www.youtube.com/watch?v=qaiwalDyayA]. In the first article [https://blog.colinbreck.com/integrating-akka-streams-and-akka-actors-part-i/] of this series, I described the basic patterns for interfacing the Akka Streams API and Akka Actors. In the second article [https://blog.colinbreck.

I expand on these concepts in my Reactive Summit presentation [https://www.youtube.com/watch?v=qaiwalDyayA]. In part one [https://blog.colinbreck.com/integrating-akka-streams-and-akka-actors-part-i/] of this series, I described the challenges of integrating the Akka Streams API with Akka Actors. I demonstrated the basic patterns for interfacing streams and

A year ago, I accepted a team lead position. As I wrote at the time [https://blog.colinbreck.com/on-being-a-team-lead-welcome-to-our-team/], I have had a number of opportunities to be a team lead, but I have always declined them, choosing a more technical role, to become a better engineer. In this

I expand on these concepts in my Reactive Summit presentation [https://www.youtube.com/watch?v=qaiwalDyayA]. Most people are attracted to Akka with the promise of the actor model providing a better abstraction for building scalable and resilient distributed systems. Since Akka attempts to solve such a challenging set

I expand on these concepts in my ScalaDays presentation in Berlin [https://www.youtube.com/watch?v=ilhImUjF53A] and New York [https://www.youtube.com/watch?v=hpQJLQ_8N1c]. I have spent my entire career building infrastructures for streaming data to support the monitoring and control of industrial applications. I

I expand on these concepts in my ScalaDays presentation in Berlin [https://www.youtube.com/watch?v=ilhImUjF53A] and New York [https://www.youtube.com/watch?v=hpQJLQ_8N1c]. I have been using the Akka Streams API [http://doc.akka.io/docs/akka/2.4.16/scala/stream/stream-introduction.html]

This article was the basis for my talk at QCon London 2017 [https://www.infoq.com/presentations/quality-views-technical-debt]. I also wrote a follow-up article Reflections on Using Quality Views [https://blog.colinbreck.com/reflections-on-using-quality-views/]. I have worked on infrastructural software my entire career—mainly streaming-data systems [https://blog.colinbreck.com/

Making the transition from procedural, synchronous programming to fully-asynchronous programming, can be challenging. Or, it can be quite easy. If all of the languages, frameworks, and services that you are using naturally support asynchronous programming, it can be straightforward to adopt, making it easy to build scalable applications. The biggest