Dusty Phillips Codes

Portable Computing Setup

Thu, 08 Jan 2026 19:33:28 -0400

I know from experience that if I use a laptop keyboard for any length of time, I will be forced to do voice coding for months while the RSI heals.

Therefore I don’t own a laptop. For the past five years this has meant I’m chained to my desk if I want to do any coding or computing (though a tablet and pencil have been my go-to for non-typing tasks such as easy web browsing).

Some Gleam Projects

Mon, 05 Jan 2026 06:00:54 -0400

I spent most of my winter break in my wood shop, working on some tech adjacent projects that I will post about later. However, I also spent a fair amount of time at my keyboard, working on a handful of gleam projects I wanted to introduce here.

I’m theoretically working on a small full stack application, but as so often happens with me, I was sidetracked by developing open source libraries that I have no hope of keeping maintained. So these projects are all in support of full stack web development on lustre and wisp.

My AI-Driven Identity Crisis

Sun, 08 Jun 2025 09:09:24 -0300

I love coding. I love writing. I love writing about coding, as evidenced by the archives of this blog and the multiple tech books I have written.

I’ve always prided myself on being able to explain things clearly. I have a unique ability to identify the order in which to teach concepts. I have enough five star reviews on my books to know that there are plenty of readers out there who agree with me.

Build a Wasm Compiler in Roc - Part 16

Sat, 07 Dec 2024 11:43:44 -0300

In earlier articles, we have implemented a tokenizer, parser, and transformer to convert WAT syntax to a Wasm AST, and got started on the code generation.

In this part, we’ll finally wrap up code generation and be able to compile our hello world sample into something that wasmtime can run.

I hope.

Build a Wasm Compiler in Roc - Part 15

Sun, 01 Dec 2024 14:43:44 -0300

In earlier articles, we have implemented a tokenizer, parser, and transformer to convert WAT syntax to a Wasm AST, and got a good portion of the code generation step in place.

Unless there are any unexpected detours, this part will cover more code generation and take us through a messy refactor that Roc helpfully makes not so messy!

Build a Wasm Compiler in Roc - Part 14

Sat, 23 Nov 2024 14:43:44 -0400

In earlier articles, we have implemented a tokenizer, parser, and transformer to convert WAT syntax to a Wasm AST and got started on the code generation.

This part will continue with code generation. We’ll start with the import section because it has a couple interesting complications that we need to take into account.

The Import Section

Consider this wat import statement:

(module
    (import "wasi_snapshot_preview1" "fd_write" (
        func $fd_write (param i32 i32 i32 i32) (result i32))
    )
)

If we look at the bytes in the binary representation of this section, it’s surprisingly long:

Build a Wasm Compiler in Roc - Part 13

Sat, 09 Nov 2024 11:43:44 -0300

In earlier articles, we have implemented a tokenizer, parser, and transformer to convert WAT syntax to a Wasm AST, and started building a code generator to create bytes from that AST. The structure of the code generator is in place already, so our remaining task is to generate all the other sections of our input module.

Data section

The next section I want to implement is the data section, which is described in the Wasm spec here.

Build a Wasm Compiler in Roc - Part 12

Fri, 01 Nov 2024 14:43:44 -0300

In earlier articles, we have implemented a tokenizer, parser, and transformer to convert the Web Assembly Text Format to an Abstract Syntax Tree that can hopefully easily compile to Wasm.

Truthfully, the next step should be validation. Validation is the process of statically analyzing the syntax tree to catch as many errors as possible. This is where things like type checking and borrow checking happen, for example.

The wasm spec has an in-depth description of what validation should look like for a conforming compiler. But we are not building a Wasm-conforming compiler. We’re barely even building a Wasm-looking compiler! The truth is, static analysis gets its own university class and textbook, distinct from the complier classes and textbooks, so I think we can be forgiven for skipping it.

Build a Wasm Compiler in Roc - Part 11

Tue, 29 Oct 2024 13:43:44 -0300

In earlier articles, we implemented a tokenizer and parser to convert Wasm’s WAT syntax into an S-expression abstract syntax tree and started to implement a transformer to convert that AST into one more suitable for generating Wasm bytecode.

This article continues where we left off, building the last piece of the transformer. This piece needs to represent arbitrary instructions inside a function body, so it’s going to take a bit of massaging. But we’ll get there!

Build a Wasm Compiler in Roc - Part 10

Thu, 17 Oct 2024 10:15:44 -0300

Now that the boilerplate is in place, this article will continue to implement recursive transformer functions, getting into some of the more complicated expressions in the “hello world” WAT example.

I should mention that the code in this article gets long and repetitive. I’m including all the code we’ll need for the hello world example, but if you feel like it’s getting a bit boring, feel free to skim bits of it! I now understand why most “introduction to compiler” articles focus on such a tiny amount of syntax! I feel committed now, though, so if you’re willing to bear with me, we’ll see this through to the end.

Build a Wasm Compiler in Roc - Part 9

Mon, 07 Oct 2024 14:43:44 -0300

In earlier articles, we implemented a tokenizer and parser to convert Wasm’s WAT syntax into an S-expression abstract syntax tree, and started to implement a transformer to convert that AST into one more suitable for generating Wasm bytecode.

This article continues where part 8 left off, as we try to expand the parser to something more than an empty WAT (module).

Reminder: You are reading content that took a great deal of effort to craft, compose, and debug. If you appreciate this work, consider supporting me on Patreon or GitHub.

Build a Wasm Compiler in Roc - Part 8

Wed, 02 Oct 2024 10:43:44 -0300

In earlier articles, we implemented a tokenizer for the Wasm text syntax (WAT) and started on a parser to convert those tokes to a S-expression AST.

In this part, we’ll start to create a transformer to convert that AST to a new one that better matches the WASM output we will be crafting. Don’t ask me how many parts that’s going to take!

Reminder: You are reading content that took a great deal of effort to craft, compose, and debug. If you appreciate this work, consider supporting me on Patreon or GitHub.

LazyVim for Ambitious Developers Now Available

Fri, 27 Sep 2024 11:20:43 -0300

It’s been a while since I published the last chapter of LazyVim for Ambitious Developers on the website, but I was waiting for the print edition to be available to share it widely. And that required waiting (twice) for proofs to be mailed to me.

But it’s finally here! For a direct link to purchase the print edition, click here.

I’m proud of the book contents. I’m pretty confident that even seasoned Vim power users would pick up one or two tricks they didn’t already know. I didn’t cover everything, of course. I’m sure those same power users can come up with tips to make it even better.

Build a Wasm Compiler in Roc - Part 7

Tue, 24 Sep 2024 10:33:44 -0300

In earlier articles, we implemented a tokenizer for the Wasm text syntax (WAT). In part 6, we started building a parser. We ended that part on a bit of a down note when I realized we were in for yet another refactor. I’m in a better mood today and it’s looking like it won’t be so bad, after all!

Reminder: You are reading content that took a great deal of effort to craft, compose, and debug. If you appreciate this work, consider supporting me on Patreon or GitHub.

Build a Wasm Compiler in Roc - Part 6

Sat, 14 Sep 2024 18:43:44 -0300

In earlier articles, I introduced this “WAT to Wasm compiler in Roc” project, wrote some Roc code to load an input file, and implemented a tokenizer for a “hello world” of Wat to Wasm compilation. It was… more work than I expected. Four blog posts more work, to be precise! I have no idea where it’s going to end.

But I do know what’s next! Parsing.

Reminder: You are reading content that took a great deal of effort to craft, compose, and debug. If you appreciate this work, consider supporting me on Patreon or GitHub.

Build a Wasm Compiler in Roc - Part 5

Fri, 06 Sep 2024 08:43:44 -0300

In earlier articles, I introduced this compiler project, wrote some Roc code to load an input file, and started implementing a tokenizer with error handling.

I think I need to admit that I have absolutely no clue how to estimate how long a blog article is going to be. I thought “build a compiler” would be one article. And then I thought “build a tokenizer” would be one article. sigh

I swear we’ll be done with tokenizing at the end of this post. But first we’ll take a detour to have a look at Roc’s very elegant built-in testing syntax.

Reminder: You are reading content that took a great deal of effort to craft, compose, and debug. If you appreciate this work, consider supporting me on Patreon or GitHub.

Build a Wasm Compiler in Roc - Part 4

Thu, 29 Aug 2024 14:43:44 -0300

In earlier articles, I introduced the project, wrote some Roc code to load an input file, and started implementing a Tokenizer.

This part takes a bit of a detour with a refactor to support rudimentary error reporting.

Reminder: You are reading content that took a great deal of effort to craft, compose, and debug. If you appreciate this work, consider supporting me on Patreon or GitHub.

Handling Errors during Tokenizing

Before we start adding more tokens to tokenize the Hello World module, I want to beef up our error handling a bit. There are a few reasons I don’t like the basic dbg nextByte we are currently using the wildcard arm:

Build a Wasm Compiler in Roc - Part 3

Thu, 22 Aug 2024 09:43:44 -0300

In part 1 and part 2 of this series, I introduced the project and we wrote some Roc code to load an input file and save the compiled result to a different file.

Note: Other articles in this series are collected here.

However, we are a long ways from actually having that compiled result available! This article introduces the phases involved in writing a compiler and focus on implementing the first phase, known as lexical analysis or tokenizing.

Roc Articles

Sat, 17 Aug 2024 10:07:04 -0300

Table of contents for my series on building a WASM compiler in Roc:

Build a Wasm Compiler in Roc - Part 2

Thu, 15 Aug 2024 14:43:44 -0300

My latest hair-brained project is a WAT-to-Wasm compiler written in the Roc programming language. I explained my (ir)rationale for the project in Part 1 of this series, which also included an introduction to the technologies we’ll be using.

Note: Other articles in this series are collected here.

In this article, we’ll get started writing some Roc code. We won’t get to the point where we are doing anything with WAT or Wasm, yet, but we will be able to load an input file and parse some command line arguments.

Build a Wasm Compiler in Roc - Part 1: Introduction

Sun, 11 Aug 2024 09:47:30 -0300

I’ve been curious about the Roc programming language for a while now, but I haven’t had/taken the time to really dig into it. I’ve read through the tutorial several times, but only yesterday did I actually sit down and install Roc and implement the tutorial. Today, I woke up with the ridiculous idea to build a compiler in the language.

A simple compiler, to be clear.

LazyVim for Ambitious Developers

Thu, 25 Apr 2024 15:22:43 -0300

I’m working on a new book! This one will be published online with plenty of begging for support on my Patreon. If there is sufficient interest, I’m planning physical and ebook editions later this year.

LazyVim for Ambitious developers is a book for the modal-editor-curious out there. Vim and Neovim have a reputation for being hard to learn and configure. LazyVim really negates that reputation, but its documentation still assumes that you have a lot of prior knowledge with Vim and Neovim.

Extolling the Virtues of Dexie Cloud for Backendless Development

Wed, 27 Mar 2024 08:50:24 -0300

Dexie Cloud was released publicly today, and I love this product so much that I want to lend my voice to the marketing effort.

Dexie.js is an incredible library for interacting with IndexedDB in the browser. It wraps the sometimes-obtuse (and oft-buggy) IndexedDB APIs with much more developer-friendly interfaces. And it is fully reactive; if you change something in the database, your React, Svelte, Vue, Angular, or Solid.js (Solid support is weak) app will live update all by itself! It’s a truly heavenly coding experience.

However, web users do not live in a vacuum, and storing things in IndexedDB is fraught. The browser may delete that data on a whim, and who among us only has one device these days? You might be able to use IndexedDB as a cache, but it can’t be your source of truth.

Until today.

We Rewrote our React App in Svelte in Three Weeks

Wed, 20 Mar 2024 08:50:33 -0300

My wife and I have been working on Fablehenge—a writing app for novelists—for several years. It had been a free time project where we’d push hard over a few weekends, then let it sit idle for a couple months perhaps tinkering in the evenings when we had a bit of time.

At the beginning of this year, I decided to take a sabbatical, which was supposed to involve cutting new hiking trails and woodworking. While it has done that, I found I’ve also been working on Fablehenge (more or less) full time.

How Inko Does Safe Concurrency

Thu, 06 Jul 2023 11:43:03 -0300

In my last article on Inko, I implemented several data structures to demonstrate how Inko’s single ownership model works.

In this article, I will expose a big lie in that article and also dive into how Inko safely handles concurrency.

Why Concurrency is Hard

Truth be told, concurrency is hard for a lot of reasons, but the one that comes up most often is concurrent memory access. If you have two threads of execution running at the same time, and they both read from and/or write to a variable, the variable is likely to end up with incorrect or garbage data.

Understanding Inko Memory Management Through Data Structures

Mon, 26 Jun 2023 09:20:26 -0300

I briefly described Inko’s unique memory management model in my previous article. In this one, I want to go into a little more detail on single ownership and move semantics by implementing a few linked lists, and a couple graphs. This is a tutorial about Inko and not about data structures, so I am assuming that you have a passing knowledge of the data structures in question (or know how to use a search engine to get that passing knowledge).

Why I'm Excited About Inko

Tue, 30 May 2023 19:24:52 -0300

I’ve spent much of my free time (if there is such a thing) over the past few years researching various esoteric programming languages for no reason whatsoever. Some of my favourites include Rescript and Gleam, which target the Javascript and Erlang ecosystems, respectively.

But I’ve really been looking for something a little more native. It seems to me that there is a big gap on the language spectrum, somewhere between Rust and Go:

Installing Inko 0.11 On Macos

Sun, 21 May 2023 11:04:41 -0300

UPDATE: I’ve updated the Inko Formula on Homebrew to 0.11.0, so you may just want to use brew install inko instead. That said, There are a few bugfixes on Inko that didn’t make it to the 0.11.0 release, so you may want to build off the main branch instead.

I have a blog article in progress about why I’m super excited about the Inko Programming Language. It’s nowhere near completion, however, and I wanted to share how I got the latest version Inko running on MacOS (Ventura).

How I Reconfigured Neovim From Scratch

Sun, 14 May 2023 11:45:15 -0300

Throughout my career, I’ve at least tried most of the available programming editors. More than two decades ago, I heard about the vi-vs-emacs debate, and made a pact with myself to use both for at least a year before deciding which I preferred.

I started with vim, switched to emacs after a year, and decided I preferred vim. I joined the sublime-text bandwagon for a year or two in the early 2010s, switched back to vim in the middle of the decade, and eventually did the big switch to vscode.

A Tutorial Introduction to Gleam -- Part 6

Wed, 27 Jul 2022 15:47:47 -0300

Introduction

This is the sixth in a series of articles exploring the Gleam programming language. In this one, I’m setting aside my little password cracking project to look at gleam for frontend development.

I love Rescript for frontend development, it’s a very practical functional programming language, and I’ve written a lot on the topic. So this article will also be a bit of a comparison of Gleam and Rescript. This isn’t really a fair comparison as Rescript is a mature language, and Gleam’s Javascript support is super brand new. I do not expect Gleam to supersede Rescript as my favourite frontend language, but stranger things have happened.

A Tutorial Introduction to Gleam -- Part 5

Sun, 24 Jul 2022 10:47:47 -0300

Introduction

This is the fifth in a series of articles exploring the Gleam programming language. In the most recent article, we started exploring how Gleam interfaces with ERLang’s powerful OTP concurrency framework to brute force some passwords. However, it was suboptimal, partially because I didn’t know what I was doing, and partially because I didn’t have time to go into some of the deeper details. I also had a super valuable tip from the Gleam discussion group that I wanted to go into.

A Tutorial Introduction to Gleam -- Part 4

Sun, 05 Jun 2022 11:47:47 -0300

Introduction

This is the fourth in a series of articles exploring the Gleam programming language. The first article explored some of the most basic features of Gleam; just enough to say hello. The second discussed looping constructs, namely that gleam doesn’t have them. The third was supposed to be about parallel programming and OTP, but it ended up being more about looping and recursion.

So this one is about parallel programming and OTP. Every other programming text I’ve written leaves concurrency until quite late because most programming languages make concurrency hard to get right (My will-never-be-published book on Rust took very serious issue with their “fearless concurrency” claims).

Gleam Articles

Sun, 05 Jun 2022 10:07:04 -0300

I’ve started a tutorial-style series on the Gleam programming language and wanted to collect them together here.

A Tutorial Introduction to Gleam -- Part 3

Mon, 23 May 2022 16:03:47 -0300

Introduction

This is the third in a series of articles exploring the Gleam programming language. The first article explored some of the most basic features of Gleam; just enough to say hello. The second discussed looping constructs, namely that gleam doesn’t have them.

This one was supposed to investigate how Gleam integrates with Erlang’s famous OTP library for concurrency and fault tolerance. But I got sidetracked and ended up doing a second article on recursion and tail recursion instead.

Fast, Bare, Rescript React (2022)

Sat, 07 May 2022 12:29:47 -0300

(Original published September 30, 2021. Updated May 7, 2022)

Introduction

Most of my Rescript series so far has been about combining Rescript with React using create-react-app. Now that I understand Rescript better, I’m not so sure create-react-app is a good fit for it.

Mostly because it’s slow. Rescript compiles JSX natively, so we shouldn’t need slow and hard-to-configure webpack. Most of create-react-app is about hiding the configuration of webpack from the end-user. I appreciate that. I’ve wasted more hours on webpack configuration than I care to count. But not having webpack is even better than hiding it!

A Tutorial Introduction to Gleam -- Part 2

Wed, 04 May 2022 10:03:47 -0300

Introduction

This is the second in a series of articles exploring the Gleam programming language. The first article explored some of the most basic features of Gleam; just enough to say hello.

Hello is basically the first thing we learn in any language (whether human or programming). This article explores looping in Gleam. More specifically, it explores the fact that Gleam doesn’t have any looping constructs.

That’s right: none.

Patreon

If you find my content valuable, please do consider sponsoring me on Patreon account. I write about what interests me, and I usually target tutorial style articles for intermediate to advanced developers in a variety of languages.

A Tutorial Introduction to Gleam -- Part 1

Sun, 17 Apr 2022 10:23:47 -0300

Introduction

Gleam is a newish programming language that I recently stumbled upon. It is so little-known that there aren’t really any tutorials available on it (even on the official documentation), so I decided to write my own.

Gleam transpiles to Javascript and Erlang. I’ll be focusing my attention on the Erlang side of things, as it is more mature. And to be honest, I don’t feel any reason to replace Rescript, my go-to transpiles-to-Javascript language.

Some Esoteric Languages

Thu, 14 Apr 2022 10:23:47 -0300

Introduction

I was basically flat with an illness (yes, that one) on my back for two weeks in March. I could do little more than read articles on my tablet, and for reasons I cannot explain, I began chainsmoking the documentation for as many little-known languages as I could find.

I honestly don’t know why. In the fog of illness, it just seemled a fun thing to do. I’m weird.

Rescript, Reason, Typescript, OCAML, Javascript, Help Me Choose!

Sat, 18 Dec 2021 13:00:47 -0300

Introduction

I’ve been writing plenty about Rescript this year, although I’ve taken a bit of a hiatus to focus on developing a couple (Rescript) open source libraries. I wanted to get back into blogging to answer one of the most confusing questions in the Rescript community: What is ReasonML and how does it relate to Rescript?

However, it has grown into something quite a bit bigger. Instead, we’ll be talking about the relationships between a collection of several interrelated languages, and I’ll give my opinion on which you should use.

Introducing rescript-dexie

Wed, 13 Oct 2021 12:29:47 -0300

As hinted in some of my recent articles on Rescript, I’ve been working on bindings to the wonderful Dexie interface to IndexedDB. It’s finally ready to announce to the world (in a fairly beta format)!

rescript-dexie depends on a recent version of Rescript and the rescript-promise library.

It’s still fairly beta and I haven’t covered all the features Dexie packs in yet, but the basics are working well. It feels intuitive and gives the right mix of sound type safety and easy call sites. Let me know what you think!

Fast, Bare, Rescript React

Thu, 30 Sep 2021 12:29:47 -0300

Introduction

(Note: There is a more recent version of this article)

Most of my Rescript series so far has been about combining Rescript with React using create-react-app. Now that I understand Rescript better, I’m not so sure create-react-app is a good fit for it.

Let's Talk About Functors In Rescript

Sat, 18 Sep 2021 10:59:47 -0300

Introduction

For basic syntax, functional programming does not feel that different from other paradigms. Sure, data and behaviour are separate, so you don’t have classes or objects or inheritance, but it feels relatively the same. This is especially true in Rescript, with the pipe-first syntax almost looking like a method lookup (comparable to the self object in Python).

But if you go deeply into a study of functional languages, you start encountering bizarre words such as “monad” and “functor”. Again, this is less true in Rescript, which emphasizes pragmatism over purity. Indeed, if you search the rescript documentation for “monad”, it will come up blank, and if you search for “Functor” you get a fairly short section that almost feels like an afterthought.

Fun With Rescript Polymorphic Variants

Mon, 06 Sep 2021 09:29:47 -0300

Introduction

Polymorphic variants in Rescript are strange beasts. They aren’t generally that useful in pure Rescript programming, but are frequently necessary in binding to Javascript.

Polymorphic variants are extremely flexible (too flexible), but one of the most common uses is to represent a list of constant strings that a JS binding can accept. For example, the ubiquitous on function used for event handlers typically takes a string as its first parameter, as in on("click"...). In Rescript, you can prevent typoing that string using Polymorphic variants: on(#click).

Parsing JSON in Rescript

Sat, 14 Aug 2021 12:11:47 -0300

Parsing dynamic content such as JSON in a statically typed language can be rather daunting. This article voices some opinions about schemaless design and migrates some of the messy json parsing code from the standard library to the excellent jzon library.

"Correctly" Unit Testing Express With Rescript And Zora

Sat, 07 Aug 2021 09:29:47 -0400

In a recent article I introduced rescript-zora, a library I wrote for unit testing Rescript code with lightning fast responses. One drawback of zora is that it’s very minimal. In this article, I explore some design principles and go on a bit of a rant about the definition of the word “unit”.

Quickly Testing Rescript With Zora

Mon, 02 Aug 2021 13:29:47 -0300

I wrote Rescript bindings to the zora test framework and wanted to write about how to actually use them.

Syncing RxDB changes to GraphQL Mutations in Rescript

Sun, 27 Jun 2021 12:12:47 -0300

Continuing my explorations of RxDB and Rescript, this article hooks up mutations to allow RxDB to automatically sync its offline-enabled changes to the graphql server.

Syncing RxDB changes from a graphql server in Rescript

Sun, 06 Jun 2021 08:28:47 -0300

I’ve become quite comfortable in Rescript over the course of the past few months. So far in this long-running series, I’ve implemented an RxDB powered offline-enabled application in Rescript. I’ve also written a graphql server using express. In this article, we’ll connect the two so that the RxDB frontend can sync with the graphql database.

Graphql Endpoints to sync with RxDB in Rescript (Part 2)

Sun, 23 May 2021 14:24:47 -0300

In the previous article we implemented the sync read endpoints between our graphql server and our RXDB client. In this one, we’ll hook up the mutations.

Graphql Endpoints to sync with RxDB in Rescript (Part 1)

Sat, 15 May 2021 13:25:47 -0300

Now that our Rescript client and server have the same data model, we can hook up the graphql endpoints to sync the offline rxdb database with the graphql server.

Announcing: Python Object-oriented Programming, 4th Edition

Wed, 12 May 2021 17:40:25 -0300

My publisher recently unveiled the fourth edition of Python Object-oriented Programming. This one has a new twist: I didn’t write it!

Quickly refactoring with Rescript

Sat, 08 May 2021 09:29:47 -0300

Continuing my ongoing series on the Rescript programming language, I discovered I needed to refactor my backend to better suit the graphql queries the frontend has to make to it.

A GraphQL Server in Rescript

Sun, 02 May 2021 16:29:47 -0300

Rescript is a delightful programming language pulling in the best elements of Javascript and functional languages without the worst bits of either. In this article, we create a graphql server in Rescript.

Introducing rescript-zora

Sun, 18 Apr 2021 16:33:35 -0300

Instead of writing a new article on Rescript this weekend, I ended up writing an entire project in Rescript!

rescript-zora provides Rescript bindings to the lightning-fast zora unit testing framework. I chose zora because it has excellent SEO for “fastest javascript test framework”, and it deserves it.

Accessing RxDB from React Components in Rescript

Sat, 17 Apr 2021 09:29:47 -0300

Now that our RxDB models are complete, we can hook it up to a react app for a complete offline experience.

Modeling RxDB in Rescript, Part 3

Fri, 09 Apr 2021 08:38:38 -0300

Extending the JS bindings I’ve modelled in previous articles, in this add bindings for subscribing to queries, and hook those up to Application state.

Modeling RxDB in Rescript, Part 2

Fri, 02 Apr 2021 09:29:47 -0400

In an earlier article, I started modelling RxDB calls from rescript with the intent of building an offline-enabled Rescript app. This article continues from that base, modelling collections and queries.

Modeling RxDB in Rescript, Part 1

Wed, 24 Mar 2021 09:00:31 -0400

I wanted to explore progressive web apps, and I took the opportunity to learn about binding Rescript to existing Javascript libraries.

Using Rescript with NodeJs and Express

Tue, 16 Mar 2021 16:07:27 -0400

As part of my ongoing experiments with Rescript, I decided to implement a Node app with express.

Styling in Rescript with Emotion

Tue, 09 Mar 2021 09:50:32 -0400

In this article, we complete the Recipes single page app we’ve been developing in Rescript by styling it with Emotion, a popular framework for styling in React systems.

Firing Actions From Rescript React Components

Tue, 02 Mar 2021 09:28:37 -0400

Continuing my series on Rescript, this article covers React forms with managed state and dispatching useReducer actions when our state changes.

A Couple React Components in Rescript

Mon, 22 Feb 2021 10:37:58 -0400

Continuing my series on Rescript, I add a couple React components to the ongoing app I’ve been developing.

Dev Setup 2021

Tue, 16 Feb 2021 08:28:09 -0400

When I first encountered the Internet my peers and I thought it was great fun to share our dev setups. We were always optimizing and always looking for new ways to optimize. Not to mention showing off.

I lost interest in this practice because I settled into a system that was sufficient for my needs. Also, I didn’t have time!

But I’ve recently made a ton of changes to my workflow that some might be interested in, and I happen to have some time as I’m between jobs. So I thought it might be a good time to share!

Actions and Reducers in Rescript

Tue, 09 Feb 2021 09:22:31 -0400

As a functional language, Rescript maps beautifully to redux-style state management, without all the boilerplate

Rescript With React: Routing and Navigation

Wed, 03 Feb 2021 07:56:02 -0400

Continuing my journey to learn Rescript using a real-world react-app. In this article, we create some new components.

Setting Up A Rescript Create-React-App From Scratch

Thu, 28 Jan 2021 07:18:40 -0400

I recently discovered the Rescript programming language and am really excited about it. I haven’t found many tutorials on the subject, so I’m documenting my steps as I go.

Ten Years

Mon, 21 Dec 2020 09:51:47 -0400

2020 has been one of my best years ever.

I know, right?

Ten years ago, I spent the Christmas season at “5 North”; Medicine Hat’s psychiatric ward. The stay started with placing my signature on a piece of paper asserting that I would not try to kill myself for 24 hours.

They asked for three days. I couldn’t promise that much time.

As near as I can figure, I had been suicidal since I was eight years old. There were two primary reasons that it took two decades to seek and receive treatment.

The Perfectionist's Guide To Doing It Wrong

Sun, 06 Dec 2020 04:01:09 -0400

A friend suffering from perfectionism has caused difficult interference in their life. I developed a technique that might be useful to others who have to deal with the negative aspects of perfectionism.

Bullet Blog?

Thu, 26 Nov 2020 04:19:11 -0400

I am trying a new blogging format hoping that I can post interesting content more often. Looking for feedback on the format.

On Voice Coding

Sat, 15 Feb 2020 04:52:00 -0400

_{(contains amazon affiliate links)}

I have had repetitive stress injury (RSI) flareups on and off for many years. I’ve kept them under control mostly through use of a Kinesis Advantage ergonomic keyboard that I’ve had for fifteen years. However, several months ago, I was diagnosed with carpal tunnel syndrome and instructed to avoid typing if at all possible.

I make my living programming and writing. My hobbies are programming and writing.

What happens if a short-seller goes bankrupt?

Sun, 11 Aug 2019 11:33:44 -0300

I’ve been wondering what to do with this blog for a while. I haven’t had time to do the technical deep dives I used to do. But I’ve also been reluctant to pivot into different kinds of articles. I’ll write more about that in the future (the summary is that I’ve been writing fiction instead of code in my free time). For now, however, I’ve decided to publish a non-technical shallow dive on something I do not understand very well: stock markets and economics.

Goals Vs Happiness

Sun, 16 Dec 2018 13:30:57 -0400

I am not a productivity coach. I don’t even like the concept of a productivity coach. I’m also not a mental health coach, although I am successfully managing mental illness, and I assure anyone dealing with depression, mania, or anxiety right now, that you matter. Things can and will get better.

I haven’t written much about mental health since I rebooted my blog. Today, I want to talk about how goals affect our state of mind.

Differences Between Writing Fiction and Nonfiction

Mon, 10 Dec 2018 19:00:54 -0400

I’m about halfway into writing my first novel. Though I have plenty of writing experience, this is my first real attempt at fiction. I’ve been surprised at the difficulty! Some of my skills transfer over; I still know the basic structure of the English language and I put commas in the right places more often than not, for example. But many other things are much different.

The hardest change I’ve had to make is the order I present information. In a nonfiction book, I try to present everything in a logical order with as much clarity as possible. Each step should lead to the next step in a way that is comfortable and non-intimidating to the reader.

An Order to Learn to Program, Part 6

Sat, 17 Nov 2018 14:53:29 -0400

Parts in this series

Part 6: Local Development

This is part 6 in my series on the order to study topics related to programming. This series aims to provide a gentle path to follow as you explore this fascinating field. The goal is not so much to get you a job in the field, but to help you to take on a new hobby.

Announcing: Python 3 Object-oriented Programming, 3rd Edition

Tue, 30 Oct 2018 18:46:32 -0300

Python 3 Object-oriented Programming 3rd Edition

My publisher unveiled the third edition of Python 3 Object-oriented Programming today! This has been the culmination of several months of work.

Editing and updating the second edition was a pleasure. It was gratifying to discover that the content has aged well. This was not the case with the first edition; I did extensive restructuring and rewriting before I was satisfied with the second.

Should languages be designed with editor support in mind?

Fri, 12 Oct 2018 11:36:08 -0300

One of many things I love about Python is how whitespace is an integral part of the language. Python was the first popular programming language designed with the idea that “code is read much more often than it is written.” Forcing authors to indent code in a maintainable fashion seemed a brilliant idea when I first encountered Python fifteen years ago. The lack of braces scattered throughout the code made for easier reading. Somewhat ironically, it also makes the language easier to write: Typing the brace character requires a certain amount of finger gymnastics.

An Order to Learn to Program, Part 5

Wed, 19 Sep 2018 11:38:28 -0300

Parts in this series

Part 5: Beginner programming, dynamically typed

This is part 5 in my series on the order to study topics related to programming. This series aims to provide a gentle path to follow as you explore this fascinating field.

An Intermediate Guide To RSA

Thu, 13 Sep 2018 12:18:27 -0300

The venerable RSA public key encryption algorithm is very elegant. It requires a basic understanding of modular arithmetic, which may sound scary if you haven’t studied it. It reduces to taking the remainder after integer long division. The RSA Wikipedia article describes five simple steps to generate the keys. Encryption and decryption are a matter of basic exponentiation. There’s no advanced math, and it’s easy to understand their example of working with small numbers.

An Order to Learn to Program, Part 4

Thu, 06 Sep 2018 15:38:28 -0300

Parts in this series

Part 4: Binary, bits, and bytes

This is part 4 of my series on the order to study topics related to programming. This series aims to give people a gentle path to follow in order to be able to dabble in this field. It is oriented toward people who are easily frustrated and therefore give up quickly.

React Redux Firebase With Firestore Tutorial

Sat, 25 Aug 2018 13:18:27 -0300

Whenever I start a new hobby web project, I just want to jump in and start coding.

Instead, I spend many many hours trying to get authentication to work. I’ve got half a dozen half-finished “boilerplate” projects lying around that were supposed to satisfy the desire of, “next time, I can use this boilerplate and authentication will just work.” It never does.

One thing I know I don’t want to do is manage my own auth database anymore. It’s too risky, and keeping a Django (for example) instance patched and up-to-date is more devops overhead than I’m interested in.

An Order to Learn to Program, Part 3

Wed, 22 Aug 2018 19:25:20 -0300

Parts in this series

Part 3: SQL Basics

It’s not common to see SQL as the next language taught after HTML. Most authors would jump to a full-fledged structured programming language like Python or Javascript instead. There are a few reasons that I think SQL is a better next choice. While it’s a lot more complicated tool than the formatting languages you’ve been working with, SQL is designed for a specific purpose and is therefore not as overwhelming as a general purpose programming language. It also uses an English-like language that might be more familiar than those other languages. In fact, it was originally designed for use by non-programming business people, although it never achieved that goal.

Computer Vision in Three Lines of Code plus a bunch more lines

Wed, 15 Aug 2018 15:37:18 -0300

My wife and I both have a tendency to leave the garage door open. You’re in and out, grabbing garden tools or supplies, and at the end of the day you enter the house through the back door and forget to check the garage. Luckily, we live in rural Canada, surrounded by wonderful people, where the door could sit open for days without anything “disappearing”. But it still makes me feel nervous to discover it’s been forgotten, if only because it is a waste of heat in the winter (not to mention the chance of blowing full of snow!). I tried a couple ways to solve the problem:

Python: Loading pathlib Paths with argparse

Mon, 13 Aug 2018 11:15:16 -0300

I really appreciate Python’s pathlib module for managing filesystem stuff. While I don’t love the argparse module for command line parsing, I don’t think it’s worse than other available options. I usually choose it for my CLI scripts, since nothing else is good enough to overcome the inertia of using a third party library.

Not many people seem to be aware that the two can very easily be combined such that argparse will return Path objects instead of strings that need to be adapted after you query them:

An Order to Learn to Program, Part 2

Fri, 10 Aug 2018 13:03:01 -0300

Parts in this series

Part 2: HTML

This is the second in a series on the order to study topics related to programming. There are countless resources out there for learning to code, so many that it becomes overwhelming to decide where to start. The goal of this series is to help you get introduced to the topic as gently as possible. I’m not writing the instructional content on each topic, but giving pointers to the resources you need to accomplish each section.

Refund for Contribution?

Sun, 05 Aug 2018 11:31:56 -0300

I accidentally started working on a new personal project for budgeting that I think others might be interested in. I haven’t open sourced any projects in quite a few years now, but if I actually finish an iteration of this project, I think I’ll probably share it under an open licence.

While I’ll be running the service locally, it is implemented entirely in Javascript React, and could easily be deployed as a SAAS. I was considering sharing it as a hosted service and charging a small fee for it, a little to cover the hosting costs and a little extra for my time. I’m not interested in growing or maintaining a startup, but it would be worthwhile if I could get a couple hundred users each spending a couple bucks a month to support a project they find useful.

An Order to Learn to Program, Part 1

Tue, 31 Jul 2018 15:14:03 -0300

Parts in this series

Part 1

Learning to program is hard. There are a few reasons this is the case:

Programming itself is hard. However, this is less true than most people believe. Programming professionally is pretty difficult. But doing basic cool stuff that makes you feel accomplished is quite easy.
There are many “specializations” in programming. A beginner programmer isn’t going to know what all those are, let alone which one they are interested in. You shouldn’t have to choose the first programming language you want to learn before you know what programming languages are. You shouldn’t have to decide between mobile apps, games, data science, artificial intelligence and various types of web development before you understand the basic programming structures.
Setting up all the programs and tools (coders call this the ‘development environment’) needed to write software is hard.
Everything you need to know seems to depend on knowing all the other things that you need to know. It becomes really tricky to decide what to learn first.

This post is the first in a series intended to address all these points, especially the last two. I want to present easy-to-digest steps that anyone who can use a web browser should be able to follow to learn the basics of coding. The end goal might be to just give you a stab at a new hobby. Or maybe you’ll love it and end up with a new career in a lucrative field. Either way, I hope those programmer friends who have been urging you to try programming have recommended this post to you.

Hacking Happier

Thu, 26 Jul 2018 00:00:00 +0000

Back in 2012, I wrote a book called Hacking Happy. It was my first self-published work, and I was actually surprised by how well it did without a publisher or marketing behind it. I had plenty of positive feedback including more than one hopefully exaggerated, “This book saved my life.” Most of the feedback was a bit more sedate, but I received a lot of private messages thanking me for writing it.

I'm Back

Wed, 25 Jul 2018 00:00:00 +0000

Hi there, I’m Dusty. Welcome to my resurrected blog.

I started a tech blog in 2007 that I maintained with regular posts for several years. While it was well-regarded at the time, I took it down in late 2016 for several reasons. First and most obviously, I became extremely busy, and simply did not have time to keep up the schedule and quality of my writing. That reduced availability coincided with my taking on a new role with Facebook in late 2013. Working on infrastructure at Facebook scale requires understanding problems and technologies that are only interesting to the largest dozen or so tech companies in the world, and many of them are proprietary. As a result, I ran out of blog topics that would be of interest to the general population. Third, the blog was throwing frequent database errors and I didn’t have the time or interest to maintain it. I figured my audience would mostly have abandoned it by that point due to infrequent posting and intermittent availability.

Books

Mon, 23 Jul 2018 10:07:04 -0300

I’ve written a few books over the years:

LazyVim for Ambitious Developers	Introduces the excellent LazyVim distribution to developers new to modal editing. Published online for free with print and ebook editions also available.
	Python Object Oriented-Oriented Programming launched my career, both as a programmer and as a writer. I wasn't able to do the revisions for the fourth edition, and passed the torch for this latest version.
	Creating Apps in Kivy covers the exceptional Kivy framework for developing efficient mobile and desktop apps in Python. Note: The book is still relevant, but decidedly outdated.
Hacking Happy	Hacking Happy was about applying programming and IT concepts to mental health. I've taken it off the market for reasons discussed in this post.

Rescript Articles

Mon, 23 Jul 2018 10:07:04 -0300

My most popular series is my ongoing list of Rescript articles. It’s gotten so long now that I’m tired of updating the table of contents on every article each time I add a new one! So I’ve extracted it here so you can find everything in order in one place:

Many of these are meant to be read in order, though my more recent ones are stand-alone.

About Dusty

Mon, 23 Jul 2018 09:50:11 -0300

Dusty Phillips is a Canadian software developer and author. He’s been developing software for well over half his life. He spent most of his career writing Python in a wide variety of contexts: freelance consultant, first engineer at a 2 person startup, director of engineering at a startup, engineer at Facebook, a stint with the United Nations to name a few.

He’s written a few books along the way with more to come. He holds a bachelor’s degree in Computer Science and Information systems from Athabasca University and a Masters in Computer Science and Engineering from York University.