This is the developer and engineer sketchpad for digital product consultancy, Red Badger.
  • WebAssembly Memory Growth and the Detached ArrayBuffer Problem

    Chris Whealy
    When JavaScript acts as the host environment for WebAssembly, shared memory is visible to JavaScript as an ArrayBuffer. WebAssembly memory is allowed to grow, but JavaScript ArrayBuffers are not; so what happens when your Rust program (compiled to WebAssembly) asks for more memory?
  • Human-centered Code Reviews

    Niall Bambury
    An examination of the practices, values and ways of working that underpin effective code reviews
  • In defence of the testing pyramid

    Viktor Charypar
    I don’t think there’s anything wrong with the testing pyramid. It’s just not quite detailed enough to be useful. Good first approximation, but we can do better.
  • Creating a Miro Clone in the browser

    Cedd Burge
    We recently worked with a client who asked us to create a freestyle web canvas, for adding various types of 'Card'.
  • Plotting Fractals in WebAssembly

    Chris Whealy
    This set of blogs builds a progressively more optimised set of WebAssembly Text programs that plot the Mandelbrot and Julia Sets.
  • Introduction to WebAssembly Text

    Chris Whealy
    An introduction to programming directly in WebAssembly Text
  • Write Better Build Scripts

    Stuart Harris
    We need simple and efficient build automation both locally, when developing, and in CI pipelines. The use case is slightly different but the goals are the same — scripts need to be simple to write, simple to read and understand, and they need to be repeatable, but we don’t want to repeat unnecessary work.
  • toString || !toString

    Chris Whealy
    toString, or not toString?
    That is the question—
    Whether 'tis nobler in the mind to suffer the slings and arrows of outrageous type coercion...
  • Next.js Deployment on Netify with Github Actions

    Rui Ramos
    A practical, hands-on guide on how to deploy your Next.js app on Netlify using Github Actions as a CI/CD pipeline
  • Bazel Impressions

    David Laban
    Early impressions of bazel
  • NATS Impressions

    David Laban
    Early impressions of NATS, its tooling, and how it fits into the universe
  • wasmCloud Impressions

    David Laban
    Early impressions of WasmCloud
  • Dapr Impressions

    David Laban
    Early impressions of dapr, its tooling, and how it fits into the universe
  • Infrastructure Musings

    David Laban
    Semi-structured musings about what my vision of infrastructure nirvana is, and what's available at the moment to help us on our way there
  • Safe From the Wolves - Building Security In

    Tim Lee
    Last week I virtually attended the reasonably interesting DevOpsCon London event. My main takeaway is that Shift Left on Security is the current buzz-phrase in the DevOps community, with some suggesting an expansion of the existing merger to create DevSecOps.
  • Platform (R)evolution

    Stuart Harris
    A look at how platforms for distributed systems are evolving — how they are rising up to meet ever lighter workloads — and charting a journey from Kubernetes, through Istio and Dapr, to wasmcloud and beyond.
  • Microfrontends

    Matt Thomson
    As we build larger and larger single page apps, it becomes increasingly difficult to maintain the codebase, particularly if multiple teams are working on it
  • Networking with a Raspberry

    Tim Lee
    Want to learn about networking, proxies and web servers? Read on.
  • a11y is your ally

    Pedro Martin
    Accessibility for the Web practices by offering a software engineer perspective
  • What's Next, After Kubernetes?

    Stuart Harris

    Kubernetes is really good. But it does nothing to address what I think is one of the biggest problems we have with microservices — the ratio of functional code (e.g. our core business logic) to non-functional code (e.g. talking to a database) is way too low.

    In this post, I first explore the Onion architecture, how it applies to microservices and how we might peel off the outer, non-functional layers of the onion, so that we can focus on the functional core.

    Then we look at how Kubernetes can be augmented to support this idea (with a service mesh, and a distributed application runtime).

    Finally, and most importantly we ask what comes after Kubernetes (spoiler, a WebAssembly actor runtime) that can support core business logic more natively, allowing us to write that logic in any language, run it literally anywhere, and securely connect it to capability providers that we don't have to write ourselves (but could if we needed to).

  • Writing a Browser-based WebAssembly Application in Rust

    Chris Whealy
    Based on a personal project that started back in 2004 as an Excel spreadsheet, this blog describes how to create a Rust application, compile it to WebAssembly and then run in the browser.
  • Guiding Principles for Agile Technology Choices

    Viktor Charypar
    An attempt to capture some guiding principles for making technology choices - picking tools, tech stacks and making architecture decisions.
  • Full-stack Rust

    Stuart Harris
    For a while now, I've been wondering how practical it is (as of right now) to use Rust for web applications and services on the server and for web UI in the browser. So I've been spending quite a lot of time exploring the developer experience, whilst trying to understand whether Rust in the browser is actually a good idea!
  • Extending Istio with Rust and WebAssembly

    Viktor Charypar
    Istio recently released verion 1.5 and one of the major changes in it is the deprecation of Mixer in favour of WebAssembly Envoy filters. Let’s build one to see what it takes.
  • Understanding JavaScript: Hoisting

    Chris Whealy
    The JavaScript compiler uses a strategy called "hoisting" in which certain variable declarations are moved to the top of a function. Here, we take a look not only at this feature and its consequences, but also at some situations in which this behaviour does not happen.
  • Understanding JavaScript: Objects and Arrays

    Chris Whealy
    In this blog, we take a look at the fact that JavaScript Objects can be accessed as if they were arrays, and the fact that all JavaScript Arrays are in fact Objects.
  • Understanding JavaScript: Type Coercion

    Chris Whealy

    Since JavaScript is a dynamically typed language, it employs a strategy called "type coercion". This behaviour means that under certain circumstances, values of one datatype will automatically be transformed into the equivalent value of another datatype.

    In this blog we take a light-hearted look at not only how and when type coercion takes place, but also some of its more unexpected consequences.

  • Microplatforms - Product Platforms as Code

    Stuart Harris
    Microplatforms are an automation-based approach to provisioning and operating platforms running digital products and services, which emphasises autonomy of cross-functional product teams.