Blog

The True Cost Of A Quickfix

Picture this, a sprint is underway, development is running smoothly, then QA reports a rather odd bug, you begin to investigate and lo and behold you find the following comment:

// Dear programmer:
// When I wrote this code, only god and I knew how it worked
// Now, only god knows

Writing Rust NIFs for Elixir With Rustler

A Native Implemented Function is implemented in C (or Rust when using Rustler) and can be called from Elixir or Erlang just like any other function. It's the simplest and fastest way to run native code from Erlang but it does come with a caveat: a crash in a NIF can bring down the whole BEAM. This makes Rust a safer option than C for implementing NIFs as its type system and ownership model guarantee memory and thread-safety.

Failing (and winning) at planning software projects

Scoping and planning software projects of any kind is a challenging task that many teams struggle with. The negative consequences of mis-planning are manyfold – teams are unable to give reliable estimates, synchronize dependent activities (e.g. marketing) with the project's progress or maintain a high level of quality that will allow maintaining and evolving an application over the long term. In this post, I will analyse these typical problems in some detail and present techniques to address and overcome them, reducing uncertainty, risk and frustration.

The state of PWA support on mobile and desktop in 2020

Progressive Web Apps have evolved rapidly over the past few years and are now supported better than ever. In the past 2 years, Microsoft and Samsung have joined Google in the quest to actively support and promote PWAs. Since early 2020, Apple seems to have realized that not all apps belong in the App Store. With the release of iOS 13, most basic PWA features are now finally fully supported on iPads and iPhones.

There are still limitations for some operating systems (OS) and browsers, so when you are considering building a PWA it is important to take this in mind. That's why we made this overview.

How to improve the accessibility of your existing Ember app

Making sure your web app is accessible can be a daunting task. Just as having a good testing suite or an app that's responsive and works well across devices, it seems easier to achieve when you're starting a new project than when working with an existing app. Knowing where to start can be tough, therefore we've outlined how to implement accessibility tests in Ember alongside a very common case: forms.

How to Improve Kick-off Meetings to Spark Collaboration

Could some adjustments to kick-off meetings lead to a more streamlined and efficient collaboration?

Porting a site to Ember using Percy

This article details a technique where the visual testing software Percy was used to port the old Ember Guides to an entirely different technology, without anybody noticing.

The little changes that helped to transform an RFC into emberjs.com

The new landing page for Ember.js is a big project.

In 2018 there was an RFC for updating the website. Which was a great thing, but there was just a mockup for the desktop website and a few of the interactive states. No version for small screens, no layout grid or repeatable measures.

So besides development, there was the task of converting this initial design mockup into a full-featured design system with elements and components that can be reused across the large Ember.js universe for which the landing page is only the doorway.

This post highlights some of the changes I proposed and which made it to the final website.

How to over-engineer a static page

When we set out to rebuild our own website simplabs.com in 2019, we wanted to use that project as an opportunity to ignore all economic considerations (and reason you could say) and dive deep into what was technically possible. Doing so would allow us to build something that was super customized for our specific needs and highly optimized for performance. We ended up spending a lot of time and effort but are quite pleased with the result.

While we cannot recommend anyone following our example as your time is most likely better spent elsewhere, this post explains the approach we took. I will be covering topics like static pre-rendering and client-side rehydration, advanced bundling and caching strategies as well as service workers.