Posts

Posted on

Navigating the Gray with the Known and Unknown Framework

An image of the known and Unknown quadrants: known knowns, known unknowns, unknown knowns, and unknown unknowns.

Introduction

In the complex and ever-evolving landscape of software development, operating in the gray, with it’s many uncertainties and ambiguities, is a reality that every software engineer faces. It is in this realm of uncertainty, the “Known and Unknown Framework” emerges as a guiding beacon, offering a structured approach to achieve continuous clarity of purpose. This framework empowers developers to identify the facts upon which their work can be firmly grounded, driving successful project outcomes.

Continue reading “Navigating the Gray with the Known and Unknown Framework”
Posted on

Automation testing as an upfront software design technique

Homer showing an early design of the car he is designing called The Homer.
Credit: The Simpsons/20th Century Animation

Effective software development testing practices play a pivotal role in crafting robust, reliable, and high-quality software systems. While testing is traditionally seen as a validation mechanism, it’s increasingly being recognized as a potent tool for upfront software design.

By incorporating testing practices into the early stages of software development, teams can not only catch defects early but also shape the architecture, behavior, and interactions of the system. This proactive approach not only enhances software quality but also fosters a more streamlined development process.

In this article, we will delve into various testing practices that serve as upfront software design techniques, highlighting their significance in shaping software systems from inception.

Continue reading “Automation testing as an upfront software design technique”
Posted on

Confidently make code changes with the practice of self-testing code.

In the ever-evolving landscape of software development, where change is the only constant, the need for robust testing practices has never been more critical. Martin Fowler’s insightful exploration of self-testing code has illuminated a path that not only enhances the quality of our code but empowers developers with a newfound confidence to shape and mould systems with agility.

Self-testing code is “the practice of writing comprehensive automated tests in conjunction with the functional software.”

At the heart of self-testing code lies a profound benefit: the confidence to implement changes. In traditional development cycles, every alteration, no matter how minor, can lead to a cascade of unintended consequences. This uncertainty can stifle progress and hinder innovation. However, by cultivating a culture of self-testing code, we unlock greater confidence that our changes will not break existing functionality. This confidence liberates us to experiment, optimize, and innovate, transforming the development process into a journey of continuous improvement rather than a daunting tightrope walk.

Continue reading “Confidently make code changes with the practice of self-testing code.”
Posted on

Split CloudFormation Stacks

Placing all your resources into a single stack is going to create pain for you later on. Moving and renaming resources between stacks can be quite tricky. Once a resource is managed by a CloudFormation stack it’s not possible to remove that resource without deleting it, and it’s not possible to move a resource from one stack to another. Splitting up your resources across multiple stacks can really help. Here are some suggestions on how you can achieve that.

Continue reading “Split CloudFormation Stacks”
Posted on

Why Bother Blogging?

Aside from providing value to many, blogging is a way to improve your communication, skills, build your personal brand, and it can provide an additional source of income.

TL;DR

  • Your experience and knowledge can help many
  • Researching and preparing content for your blog increases your own knowledge and experience
  • Improve your ability to influence others through clear concise communication
  • Receive useful feedback from your readers
  • Build a personal brand that has companies coming to you, not the other way around
  • Create and sell digital courses based on your blog material
  • Take this free email course on how to get started blogging
Continue reading “Why Bother Blogging?”
Posted on

Safe Deployments with API Gateway and Lambda AutoPublishAlias

Take advantage of the automatic versioning and aliasing of your Lambdas to instantly shift traffic to your new API deployments. Rollback by repointing the problematic Lambda’s alias to the previous version.

TL;DR

  1. Use the Serverless Application Model (SAM) AutoPublishAlias parameter to have CloudFormation automatically version and alias your Lambdas upon deployment
  2. Reference your Lambda Alias from your OpenAPI definition
  3. Deploy
Continue reading “Safe Deployments with API Gateway and Lambda AutoPublishAlias”
Posted on

How to use OpenAPI with API Gateway

Use an OpenAPI specification to define API Gateway APIs. This is good practice because:

  1. The specification forces you to think about the design upfront before touching code which is expensive to correct later
  2. This contract first approach allows frontend, backend, and test developers to work in parallel
  3. Endpoints can be mocked for developers to test against
  4. Serverless Application Model (SAM) uses the specification to configure the API Gateway API, this makes it living documentation, evolving alongside code and infrastructure.
Continue reading “How to use OpenAPI with API Gateway”