Latest

A look back at 2024 & a bold step into 2025!

2024 was a year of breakthroughs, impact, and bold strides at Frontside. From structured concurrency with Effection v4 Alpha to revolutionizing testing with Interactors and Data-Driven Test Framework, to improving our Simulation Platform creating the Foundation Simulator. As we step into 2025, we're doubling down on empowering engineering teams and organizations to take bold steps and build with confidence. Here’s a look back at what we accomplished—and a glimpse into what’s next

Announcing Effection 3.0 -- Structured Concurrency and Effects for JavaScript

A major milestone in bringing Structured Concurrency and Effects to JavaScript, Effection 3.0 has excellent TypeScript support, a powerful new context API, and harmonizes perfectly with the JavaScript APIs you know and love.

The await event horizon in JavaScript

Why async functions in JavaScript are insufficient as a Structured Concurrency primitive

Backstage: Unblock Innersource Development with Plugins and Code Owners.

Navigating the challenges of inner-source Backstage portals? Discover how successful adopters harness code owners to streamline contributions and maintain code quality.

Backstage: How to fix linting errors without slowing down development

In this guide Min will show you a unique approach to tackling a mountain of linting errors without disrupting delivery

Deno is the best tool for maintaining NPM packages

Even if you primarily run your JavaScript in Node, Deno is a fantastic tool for building and distributing packages on NPM (and everywhere else). This article shows how to publish modules to both https://deno.land/x and https://npmjs.org using nothing more than the deno CLI.

Seven ways to build a single glass pane with Backstage

Learn strategies for integrating external services into Backstage that improve discoverability and lower congantive load for your users

Dynamic Github Action Jobs

Ever wanted to run parallel jobs in Github Actions with a high level of flexibility? We have, and now you can too!

Ingestion tests in Backstage Part 2: Safely refactoring an LDAP integration

To test whether the Backstage is setting up the Catalog properly, you must start a Backstage server, wait for a while, and assert. This feat is easier said than done. Here is part 2 in which Charles will guide you through it in this article.

Deno is "blazing fast" for humans

Every systems claims to be "blazing fast", but does that actually mean faster development?

What Is Spotify Backstage: a developer portal overview

What can Backstage do for your team? In this post, we are going to discuss how backstage can improve your organization.

Tutorial: Using Github Webhooks with Backstage Entity Provider

In this short tutorial, Min will show you how to configure Github Webhooks for Backstage's Github Entity Provider

Testing Backstage Catalog's ingestion

To test whether the Backstage is setting up the Catalog properly, you must start a Backstage server, wait for a while, and assert. This feat is easier said than done, but Charles will guide you through it in this article.

Backstage tutorial: plugin integration tests with Cypress + Interactors

In this tutorial, you'll learn how to set up integration tests for your Backstage plugins using Material UI Interactors

Announcing GraphGen: the search for the graph factory

Creating fake datasets that resemble real ones is nearly impossible today. That's why Frontside is working on a tool that can generate graphs with coherent data and relationships

Tutorial: How to use your company’s component library with Backstage

In this tutorial, Taras will show you how to replace Material UI for your component library in Backstage without losing access to its API.

When to use SemVer or CalVer: project type considerations

Choosing a versioning scheme helps you manage the understanding and expectations of your project over time. In this article, you'll learn about how to decide on whether to use SemVer or CalVer according to your project type.

What is DX anyway: a chronological overview

You can only optimize for concrete indicators, that’s why having a clear understanding of DX is important to improve it. In this article, we review the main trends of the past decade.

Tutorial: Easier onboarding with Backstage and VSCode dev containers

In this tutorial, you'll learn how to set up dev containers to make it easier to onboard developers.

Simplified local development and testing with Auth0 simulation

Auth0 can be difficult to manage in local development and within testing environments such as CI/CD pipelines. An Auth0 simulator can save you from branching your code or maintaining mocks in your tests.

Effection: for when async/await is not enough

Everyone who has built a complex system in JavaScript has hit a critical moment when concurrent processes become unmanageable. But with Effection—an OSS async/await alternative—you'll spare memory leaks and headaches.

Interactors: the design systems testing ally

Components from a design system make building UIs easy. It should be just as easy to test them. Interactors enable more robust tests for component-based UIs, and improve component libraries' maintainability.

Relieve developers’ churn in your Cloud native strategy with Backstage

Adopting Cloud native strategies has proven to improve organizations' delivery performance, but the complexity brought in with them is making life harder for developers. Using the example of a unified Secret manager, I present how Backstage can improve DX in the Cloud native world.

Unleashing the Genie: Helping both designers and developers with Storybook

Good documentation is key to design systems. However, what "good" means varies according to the reader. This article will go through tips to generate documentations for designers and developers from a single Storybook—keep everyone happy with minimum effort!

There and Back Again: Testing and Stack Upgrades

Upgrading your application stack to new major versions can be terrifying, especially when you have a massive application with 75 developers working on features non-stop. However, a good testing strategy gives you confidence to make bold moves that take your organization to heretofore unexplored lands.

Kubernetes: Dip your toes in this

Kubernetes is on the rise and having it in your toolkit can get you a long way. In this article, Min shows us how to set up a MicoK8s in your local machine.

The context dilemma: design tokens and components

Design tokens are used to keep a consistent look across an entire system. How do you name them semantically if they have to make sense everywhere but also respond to the inner logic of individual components which are independently developed?

Renaming `main` with purpose

As generic default branch names like `master` for Git repos have gone out of fashion, possibilities emerge for more effective and informative naming conventions. Learn about the branch naming strategy Frontside uses for our Open Source libraries and how we name app project branches.

MirageJS: Choosing the right Serializer

MirageJS ships with four out-of-the-box serializers. In this blog post, we overview the basics of serializers in Mirage, and examine in detail the specific format of each JSON API, Active Model, Rest and generic serializers.

Beyond Mocking: Decoupling teams through Simulation

Decoupling front-end and mobile teams from the back-end makes organizations more effective. In this article we explain why using simulation is an ideal strategy for this purpose, and present important considerations for adopting such practices.

The Lesson of BigTest Interactors: never write a flaky test again!

To prevent flaky tests, BigTest introduces the Interactor API, designed around the lessons learned in Capybara. This article introduces the benefits of Interactors in BigTest and how to use them to write reliable tests.

Github Actions: a deep dive into pull_request

We have put together specific behaviors and information that you’ll need to use pull_request as a trigger for your Github Actions workflow.

The Triple Threat to Testing — Part 2: Reliability

Flakiness: one of the biggest pain-points of any test suite. From app complexity to incident management, we explore some of the most common causes of unreliable tests.

7 reasons to write good Pull Request descriptions

A good Pull Request description can lead to better reviews, improved solutions, better documentation, and more. In this article, Taras surveys seven big wins of PR descriptions.

The Triple Threat to Testing — Part 1: Speed

Speed, reliability, and relevance constitute the mains pillars of a robust testing strategy. The faster a test suite can diagnose an issue in its application, the more value it renders. In this article, we navigate through the most significant causes of slow tests and suggest ideas to deal with them.

Case study — Facilitating the next generation of Bluetooth-connected apps

More and more teams are using Bluetooth for innovative products, but developing UIs for connected devices can be challenging: limited physical devices slow down development and make it nearly impossible to keep up a strong test suite. Our solution is simulation and Open Source power.

Build a Family Tree maker using React Hooks and Microstates

If you use React, you probably know about the React Hooks RFC that was introduced at ReactConf. It’s an exciting proposal because it promises to bring the power of class components to function components. It also a convention for creating React extensions that feel like first-class APIs in the React ecosystem. React Hooks API and Microstates bring expressiveness of React function components to a whole new level.

Four reasons to use append() instead of Object.assign() and Object spread

Object.assign is just a special case of a universal concept in functional programming. By opting to use a universal function to back this universal concept, you can inherit all kinds of awesome for free.

Kubernetes for the Kubernewbie - The Journey

Learning Kubernetes, especially with no background in Ops, is challenging but full of reward. This will take you along the journey of our k8s enlightenment and deployment

JSConf 2018 Recap

JSConfUS is back after a three-year hiatus and Robert had the chance to attend. He covers his favorite talks he saw while there!

WCAG 2.1: What does it actually mean?

WCAG 2.1 has officially been put in place as a standard but what does that mean? What was added? How does this impact my site or app? In this post we break down everything new in WCAG 2.1 and put in simple terms so you can walk away armed with the knowledge of making your site more accessibile.

Functional Rephrasing Using an Async Function Functor

Once you know that they're there, Functors pop up in all kinds of surprising places. Here we take a simple exploration of how the JavaScript async function construct is actually a Functor and how we can use that for great good.

Big Testing in React

When we write and develop our applications, it's with the intent that somebody will use it. We write tests so we can be assured that everything in our app works as expected and is bug free. But how confident are you in your tests?

Connecting a Slack Channel to Gitter

Slack communities for open source projects have become very popular over the past couple years. Slack has taken hold because it makes collaborative chat really easy and accessible for the masses. Something IRC wasn’t able to achieve.

Math is Just Another Framework

Functional programming with typeclasses rooted in category theory may seem like some esoteric practice reserved for the truly pointy-haired. But guess what? You do it every day.

Quickly Build Component Libraries with Storybook

Design systems have become an effective way to maintain consistency and improve feature delivery time. What can developers on smaller teams do to apply design system concepts?

How Healthy Is Your Build?

Staying healthy is a lot of work. Maybe you hit the treadmill before going into the office, and then on the way home you pick up some organic groceries. But be honest, you probably don't. Thankfully, maintaining your web application's build health is much easier, and the rewards can be huge! Take a few minutes to check your build health today: you might regret it if you don't.

Building a Continuous Integration & Deployment Solution for the IoT.

Smart homes, smart devices, smart vehicles. The Internet of Things is here! You want to be able to build software for IoT and deploy, maintain, and update it on your devices that may be located anywhere and within anything. This is the first part of our IoT setup connecting users to the Internet of Things.

One Helpful Way to Think About JavaScript Decorators

JavaScript decorators are coming, but what are the class of problems which they're useful for? In this brief tour of decorators, we'll try to answer that question by contrasting them with comparable technology from other languages.

React Native and Chill: A tale of stupid made fast

Building infinite scroll in React Native

Tackling infinite scroll can be hard on any platform. But thankfully React Native allows you to use base JavaScript libraries to solve problems in native apps. We're going to take Impagination.js and build an infinite scrolling list that is silky smooth and painless data management.

The Ruby DCamp Experience

The Conjoined Triangles of Senior-Level Development

Accessibility & Why it Matters

So You Just Finished a Bootcamp, Now What?

Global Accessibility Awareness Day

The Insider Track

A guide to using kindness to elevate your conference experience.

Functional Templating in Ember

See how easy it is to build a fully formed image upload widget complete with preview and progress bars when you apply functional programming techniques to your handlebars templates

X-Select Status Update

Reactive Modeling with Ember

Programming in the Wild West

Ember and the future of the web

Ember on Rails: #REALTALK

The Ruby Racer Rides Again

Implementing a Jenkins Extension Point with the Native Java API inside a Ruby Plugin

Ruby for Jenkins Goes Pre-Alpha

The Ruby Racer isn't threadsafe... yet.

What it takes to bring Ruby to Jenkins

Wrapping each Hudson distribution in its own RubyGem

We must come together to honor the command line

Accessing Javascript Objects from Ruby

RYE: Repeat Yourself Enough

In Search of a Better Autogrowing Textfield

Please Stop Using Global Variables in Ruby

Patiently waiting for JavaFX

mod_rewrite: Remeber that the version counts

Trans-Global Pair Programming

Taming the Rhino

Live Stylesheets

Learning Javascript from the Command Line