Here are my most recent articles. The full archive can be viewed here or by clicking the "Archive" link in the navbar.
The Zoom MS-70CDR+ is a single pedal sized multi-effect unit with a wide variety of effects available. The full specs can be found here. I bought the pedal roughly a year ago to go on my secondary pedal board. I've played the unit for a while and have experimented with it in multiple configurations. I'm currently using it at the end of my signal chain to handle reverb, delay, compression, and chorus.
Recently I started building a side project using Koa on the backend and Nunjucks for my template engine.
I use Django at work and I wanted an equivalent to the django template url tag.
Nunjucks provides the ability to write custom tags, so I took a stab at implementing something analogous to what I've seen in Django.
Current mainstream programming languages don't provide means of grouping code within a single function or method. Often, a function can end up being quite long even when its only doing a single task. The task itself can be complex requiring several steps and calculations but still logically be a single task. Traditional wisdom states that long functions should be broken up into separate smaller functions, but this scatters logic and becomes hard to follow. We need a facility for grouping and encapsulating code within a function. It should group logic together and be easy to comprehend.
In general, I find it preferable to return early from functions whenever possible. What I mean by this is that the code in a function should try to fail as soon as possible and exit the function. The first thing the code should do is check whether or not its possible to continue.
I recently had to move a calculation I was doing on the back-end in Python to the front-end in JavaScript.
The calculation involved grouping a list of items based on a property of each item.
I needed to iterate over a list, creating a new group of items whenever a specific property on the item changed.
The itertools.groupby function in Python's standard library behaved pretty much like I expected it to and gave me the result I needed.
After some messing around, I was able get the result I wanted by manipulating the output of groupby with the list comprehension below.
This is just a design pattern I wanted to share.
It makes complicated if/else blocks more readable in my opinion.
When writing a conditional you can sometimes end up with several expressions that are being tested.
It can look something like this:
A while back I wrote a small JavaScript program that compared the difference between functional and imperative programming styles. I figured it might make an interesting blog post so here it is.
This is a laptop stand I made completeley out of carboard. I wanted something to raise my laptop up and I had a bunch of boxes laying around so I decided to see what I could make with them. It turned out pretty well given the materials.
Here is the script I use to backup my home directory.
Its a simple bash script that uses tar and gzip to archive and compress the files.
I run it every few weeks and backup my data to another hard drive in my computer.
In this tutorial we are going to implement a small programming language using the top-down recursive descent method of parsing. Recursive descent parsing utilizes a set of mutually recursive functions to do the parsing. Each function handles a different production rule in the language's grammar. This makes implementing the parser relatively straightforward as the parser code closely resembles the grammar.