The official blog from the team at Runnable.

Announcing Runnable Environments for JIRA

We’re excited to announce Runnable Environments for JIRA is now available on the Atlassian Marketplace. This integration between Runnable and JIRA provides the ultimate collaboration experience for dev teams moving quickly to ship new features to customers.

Keep reading
Debugging Event-Driven Microservices

Debugging event-driven microservices can be a nightmare: logging is typically distributed across every service, and the event flow can’t easily be followed through code. This means debugging often involves going code-spelunking; mapping out every event that has been sent and following the chain. But this can yield complicated state diagrams with arrows crossing over themselves as you discover some events can call back up the chain — you can pull your hair out trying to keep all of it in your head.

The lesson here is that you can’t debug microservices in the same way you’d debug a monolith. But by appending some data to each event, you can start spotting issues more easily:

Keep reading
Pipelines vs. MapReduce to Speed Up Data Aggregation in MongoDB

There has been a lot of protest related to pipelines recently, but there is one that we can all agree brings value and profit to our work: the MongoDB Aggregation Pipeline. When MongoDB v2.2 was released, this performant method of data aggregation was introduced that utilizes stages to filter data and perform operations like grouping, sorting and transforming the output of each operator. This framework is an alternative to Mongo’s MapReduce functionality, and the output can be piped to a new collection or used to update specific documents.

Keep reading
How We Made Builds Faster for Our New Users

We’re always trying to eliminate points of drop-off in our onboarding flow — we want to show value as quickly as possible to new users. Recently, we applied some unconventional methods to make this happen.

The first thing a user experiences in Runnable is our demo. Our app builds environments for git branches. We want users to see what that’s like right off the bat, so we start them off with a demo application. Since it’s tied to a repository on their own GitHub account, we can’t build it in advance, which means they have to wait for it to build.

Keep reading
Amazon-like Popover Trigger Behaviors in AngularJS

Creating custom UI behavior in Angular can seem daunting. Once you know how to break the problem down, its complexity can just fizzle away. In this tutorial, we’ll be exploring the use of mouse events, locations, and some simple geometry to add an on-hover popover menu to a button. Not just any simple on-hover behavior, but one that stays open if the user is heading toward the content.

Keep reading
Conway’s Law in Reverse: How App Architecture Influences Org Structure

In my previous two blog posts, I explored how Runnable’s architecture evolved over the last two years. There’s no one-size-fits-all solution, but the microservices approach has yielded a lot of benefits for us. In this post, I’ll talk about how Conway’s law has worked in reverse for us, and what the results of that look like.

Keep reading
How We Built Docker Compose Support

In my previous post, I went over how our event-driven architecture allows us to rapidly ship new features. This post covers how we used this model to ship a new feature: Docker Compose support.

Docker Compose enables our customers to build environments on Runnable using the same configuration they use to deploy to production, staging, or wherever they currently use Docker Compose. The best part? They get this with no additional setup.

Keep reading
How is Runnable Different From CI Solutions?

After Runnable launched last September, we’ve received lots of interest from dev teams looking to improve their development process. One of the questions we often get is, “how does Runnable compare to my current CI solution?”

Keep reading