All Posts

At the very heart of Actual is a custom syncing engine. I'd like to talk about a PostgreSQL feature that enabled a 9-10x performance improvement.

This is a look at how I approach product design and all the considerations you need to think about. I explain some improvements in the recent version of Actual's budget table.

I'm joining Stripe.

Atomic commits are one of the most important properties of reliable software. Recently I improved the syncing layer of Actual using transactions, and I talk about why it's so important.

A deep dive into the relationship between growth and profit after my last post about profit forecasting.

I sit down and learn how to get insights from churn rates, conversion rates, and more to answer some important questions about my product.

A look back on Actual's progress in 2019.

Some people really hate Electron apps. They eat up memory, boot slowly, and aren't very responsive. What if I told you there's a secret that automatically minimizes these problems? They key is doing the bulk of your work locally in a background process, and doing so has some fantastic development benefits.

The last couple of years I've been building Actual. It's taken a lot out of me. Building, marketing, and trying to bootstrap a product yourself is ridiculously hard. I'm bringing my blog back to write about the path to profitability.

Over the last year I've been quietly building Actual, a personal budgeting tool. It's a free local app that will sync across all devices. I'm building it because I wanted a tool that is flexible and simple, with a solid budgeting system.

Livestreaming has always been popular in certain communities like gaming, but recently it's been getting popular with programmers. ... I plan on livestreaming while I work on a product every week.

We officially announced prettier over two months ago as a way to solve the problem of wasting time formatting your code. It started as an experiment but it clearly resonated with a lot of people, amassing ~7000 GitHub stars and over 100,000 monthly npm downloads in just two months. Now it's time for 1.0.

Several people at React Conf asked me for advice on becoming a better programmer. For some reason, people see me as a pretty advanced programmer worth listening to. I thought it would be worthwhile to write down my "mental model" for how I have approached programming over the years.

Changelog invited me to talk about open source and you can listen to it here.

Sarah and I have been married for 6 years as of today (with 2 kids, Evy and Georgia). I write about a lot about technology on my blog but I don't write about the thing that I spend more time on and is way more important than tech: my family. I thought our 6-year anniversary is a good time to acknowledge that!

Today I am announcing prettier, a JavaScript formatter inspired by refmt with advanced support for language features from ES2017, JSX, and Flow.

Last week I was in Hawaii for a Mozilla work week. I saw many great friends, but I also kept faintly recognizing people without remembering how I knew them. Sometimes I even thought I knew them from other parts of my life. It made me realize just how much Mozilla has become part of my life.

Today we're going to implement resumable exceptions. Common Lisp is known for this feature. Few other languages implement them, but I found an implementation for OCaml by (unsurprisingly) Kiselyov.

In my previous post I introduced Unwinder, a project which implements continuations (and stepping debuggers) in JavaScript. In this article I explain how the compiler is implemented.

Many people have heard the word “continuation” because it has something to do with node’s callback hell. I don’t think most people understand what continuations really are, though. They aren’t just a callback function used by async functions.

I have now used Redux pretty extensively in multiple projects by now, especially the Firefox Developer Tools. While I think it breaks down in a few specific scenarios, generally I think it holds up well in complex apps. Certainly nothing is perfect, and the good news is when you want to do something outside of the normal workflow, it’s not hard.

It’s been 6 months since my last blog rewrite, so it’s time for another one. This time, let’s subtract.

In most debuggers, a breakpoint will "slide" if the clicked line doesn't have any code. This is supposed to be a helpful feature, but it becomes **infuriating** if it behaves wrongly. In Firefox 46, we made our breakpoint sliding algorithm much more robust.

In this post, I explain why it has taken so long to get the Firefox console sourcemapped. It requires an unobtrusive debug mode which is really hard to do, but we got it working. The console now has access to sourcemaps, so we are only one small step away from getting it working.

"It’s late Friday night, my wife is already asleep, and I finally found time to go through those pull requests on that old project I put up on github last year. My daughter is getting up at 7:30 though, so I better not stay up too late. ..."

It's not clear how to use redux and react-router together on a project, but there's actually a pretty simple way to do it. Introducing redux-simple-router, a way to keep the current URL in sync in your app state and router instance.

Last week I gave a talk at ReactiveConf about how React and Redux solve a lot of issues in complex apps. I talked about how vital it is to keep things as simple as possible, and how we're trying to clean up the code of Firefox Developer Tools. Watch it here.

A little while ago I briefly talked about my latest blog rewrite and promised to go more in-depth on specific things I learned. Today I'm going to discuss various ways to use immutable data structures in JavaScript.

It's that time of year again! The weeds are growing, the air is thick and stagnant, and I just deployed another refactoring of my blog. "Why does he keep working on his blog," you're thinking, "when I could do all of that with a static-site generator like Jekyll?"

I gave a talk at a local JavaScript meetup in Richmond, VA about React Native. Here are my slides and a recording of the talk. Check this out if you want to see why React Native is so cool!

I'm probably going to regret this, but this post is about promises. There are a few details that I'd like to spell out so I can point people to this post instead of repeating myself. Here are a few reasons why I don't like promises.

Part I and Part II of this series lay the groundwork for building not only the frontend code of your app, but also the backend. So far, while the system has a nice consistency, it offers little to the casual observer. Today, in this final post, we are going to look at how to live update a running JavaScript system using webpack's hot module replacement.

In Part I of this series, we configured webpack for building backend apps. Now we will look at how to manage frontend and backend code at the same time, and integrating our system with nodemon to restart the server on changes.

Webpack is an amazing tool. This is the first post in a series about how to use it for backend apps as well as frontend. Using the exact same build process for both is amazing.

I put a lot of pressure on myself to be productive. I love to both learn and obsess about interesting ideas, but also turn them into actual productive things in real life. It's exhausting sometimes. There usually isn't enough time to do both.

I've been thinking a lot about what the web needs to compete with high-end native mobile apps. This is a list of bold statements that I think warrant discussion for getting the web to perform well on mobile.

React Native is a new way to build native apps, using all the same technology you learned with React.js. It's amazing. In this article I give a demo of my first app built with it and explain the experience.

Several months ago <a href="https://archive.jlongster.com/Blog-Rebuild--A-Fresh-Start">I posted</a> about plans to rebuild this blog. After a few false starts, I finally finished and launched the new version two weeks ago. The new version uses React and is way better (and I <a href="https://github.com/jlongster/blog">open-sourced it</a>).

Recently there's been some heated discussion over writing modular code, what that means, and which style is better. In this article I reflect on the discussion and about respecting each other.

I don't usually do these end-of-year posts, but I'm trying to write more so it seems like a good opportunity. It's also nice to verbalize where I'm at with general goals. I put a lot of pressure on myself to make progress on my goals, so it's good to take a step back and see what happened.

Over the past week I've been hard at work polishing and benchmarking my transducers library. I just published a new version with benchmarks so let's take a look at the new features and performance.

In this post we study transducers, a new technique from Clojure, for generalizing how we transform data. I have implemented them in JavaScript and released <a href="https://github.com/jlongster/transducers.js">transducers.js</a>, which will radically simplify how you deal with data transformation across all data types.

Every piece of software deals with complex control flow mechanisms like callbacks, promises, events, and streams. It turns out using CSP which leverages channels for asynchronous communication vastly reduces the complexity of everything. This has drastic effects not only on server-side code, but also on user interfaces.

To begin rebuilding my blog, I need a way to cross-compile JavaScript and have modules work in the browser. In this article, I describe all the research I did into build systems and what I ended up with.

I wrote my own blogging engine for jlongster.com two years ago, and it has served me well. The code is old and the cracks are showing, however, so I'm going to rewrite it completely with new web technologies and blog throughout development.

<a href="http://facebook.github.io/react/docs/jsx-in-depth.html">JSX</a> is a Facebook project that embeds an XML-like language in JavaScript, and is typically used with <a href="http://facebook.github.io/react/">React</a>. Many people love it and find it highly useful. Unfortunately it requires its own compiler and doesn't mix with other language extensions. I have implemented a <a href="https://github.com/jlongster/jsx-reader">JSX "compiler"</a> with <a href="http://sweetjs.org/">sweet.js</a> macros, so you can use it alongside any other language extensions implemented as macros.

I've been studying frameworks and libraries like Ember, Angular, and React the past several months, and given Web Components a lot of thought. I found React to be the most enlightening, and I'll explain why.

After 3 years at Mozilla, this week I'm joining the Firefox Developer Tools team. This will be a great fit for me, and I'm really excited to work with them and make our performance and debugger tools rock.

This tutorial explores how to write more complex sweet.js macros. There are several use cases which require more control over pattern matching, and recursive macros and pattern classes allow this and let you build abstractions when writing macros.

Back in 2009-2010, I got Gambit Scheme running on iOS and decided to build a game with it. The result was Farmaggedon, a stupid game where you blow up farm animals to avoid being hit by them.

This is the first entry in a series about writing JavaScript macros with <a href="http://sweetjs.org/">sweet.js</a>. You will learn how to write your first macro, basics of pattern matching, and how to run the sweet.js compiler and use sourcemaps for debugging.

JavaScript is everywhere, but that's a double-edged sword. It's hard for everyone involved to agree on how the language should move forward, let alone implement changes in all implementations. Some people write compilers to implement extensions, but that's bad. sweet.js is a new project that implements macros for JavaScript, and it's much better way to implement language extensions.

I wrote a JavaScript engine called Nunjucks, and it recently reached 1.0. One the new features is asynchronous templating, which lets you use async APIs inside custom filters and extensions. I'll show you how I implemented it, allowing templates to be paused when rendering and resumed later.

I've been searching for the perfect desk for the past few years. My desk needs to be sturdy, beautiful, and just the right size. After several attempts to solve this problem, I decided just to build my own. This is that story.

In my last post, I studied how combining promises and generators provides a nice solution for callback hell. Here I look at a few solutions for simply using generators, without promises at all, in node to write nice async code.

Callback hell is a real problem in node.js. Since generators have landed in V8, I take a look at how we can write code with them, leveraging promises to handle the details. This technique vastly improves code with asynchronous workflows.

While at JSConf 2013 I'm taking notes for each talk and taking pictures so that I don't miss anything. Check this out if you are interested in what's going on at JSConf.

Mozilla recently announced asm.js, a specification of a restricted subset of javascript that can be ridiculously optimized. It's difficult to write by hand, so I ported a language called LLJS to compile to it, unlocking high performance in browsers with a C-like language.

This article explores the process of creating a sprite-based game for the web using canvas. It provides an in-depth explanation of sprite animations, collisions, and much more.

After an intense few weeks building a multiplayer first person shooter on the web, I take a look at what I achieved and what I did wrong.

Now that I have a multiplayer server working for my WebGL FPS, I improve it to become an "authoritative server". It runs client-side prediction and interpolation to keep gameplay smooth but reject any cheating.

First person shooters aren't very fun unless you can play with other people. In this article I show how I implemented a basic multiplayer server for my game.

I successfuly compiled a Lisp to Javascript in Continuation Passing Style (CPS) with an acceptable performance hit, and was able to write a stepping debugger and a solution for callback hell.

I implemented CPS in Outlet and benchmarked the result, as seen here. It's very slow, but is there a way to optimize it?