Home Page on Adam Bard, Handsome Web Developer

One month with Github Copilot

Fri, 31 Mar 2023 00:00:00 +0000

I’ve been trialling Github Copilot for some weeks now, and so far I’ve been very impressed. It’s clear to me that this and similar tools will become a permanent part of many programmers’ toolkits (at least until the AI gets so clever that it obviates our jobs completely).

Transitioning Later for Reddit from Docker Machines to Digital Ocean Kubernetes

Sun, 26 Jul 2020 00:00:00 +0000

I recently completed a migration from my old docker-machine-based infrastructure (so 2016!) to Digital Ocean’s hosted kubernetes service. The bulk of the work was completed in a single evening. It went almost seamlessly, but not so seamlessly that I wasn’t able to learn a few things. The goal of this writeup is not to serve as comprehensive documentation, but hopefully you’ll take away some ideas about how to get your own setup rolling.

Getting a handle on Reduce

Mon, 17 Dec 2018 00:00:00 +0000

Although traditional algol-inspired languages remain dominant, over the past decade or so, functional programming techniques utilizing immutable data structures have seen widespread adoption in a variety of domains. From React and friends on the frontend to Map-Reduce and the vast ecosystem of thus-inspired data warehousing systems that power some of the world’s largest software applications, the ability to navigate such applications is now a must-have skill for many programmers.

The subject of today’s article is a higher-order function called reduce, also known as fold, aggregate, and others. Reduce is a fundamentally useful tool, but I find that many developers have trouble grasping and using it. My hope here is to make an approachable introduction to reduce.

Programatically Liquidating my Steam Inventory

Wed, 23 May 2018 00:00:00 +0000

I don’t know about you, but every so often my Steam Inventory gets a bit out of control. I have no use for Don’t Starve trading cards, but it’s not really worth my time to individually sell each item for a few cents. However, what is worth my time, apparently, is creating a script to do it for me. This turned out to be quite a winding road, which I’ve documented here.

One-box stream processing with CSP

Sun, 18 Feb 2018 00:00:00 +0000

If you’re like me (that is, employed by an ad tech company), stream processing is usually associated with frameworks like Storm, Flink, Spark Streaming, and other such solutions. However, a lot of real-life software can be described as stream processing – data comes in one end, is transformed or aggregated, and goes somewhere else. Many of these workloads don’t justify the overhead of a stream processor, but that doesn’t mean they can’t benefit from some of the lessons of stream processing systems.

Running a Side Business as a Programmer: The story of Later for Reddit

Tue, 19 Dec 2017 00:00:00 +0000

For the past 5 years, I’ve run a website called Later for Reddit. For the past 2 years, it’s actually been making money. Here’s how that happened. I used to spend a lot of time on Reddit (insert Mitch Hedberg joke here). I also used to spend a lot of time writing side projects, often late into the night. One problem I frequently had at the intersection of those two hobbies was that, when I posted my sweet new thing to Reddit after I finished getting it ready at 2am, it never had a chance of getting seen.

Javascript FP design pattern: Binding functions

Sat, 16 Sep 2017 00:00:00 +0000

Ok, ok, monads have been done. They’ve even been done by me before. But, functional programming is still popular, monads are still very useful for programming in an FP style, and people are entering the field every day. So here’s another attempt at an approachable introduction to usefully apply this pattern to everyday coding problems.

Bucklescript vs Elm vs Typescript: Typed Javascript showdown!

Sun, 03 Sep 2017 00:00:00 +0000

You, a web developer, have probably heard of Typescript, may have heard of Elm, and you might even have heard of Bucklescript/ReasonML as well. Each of these represents a compiles-to-javascript language with strong type support, but each has some different opinions, philosophies, and features.

In this article I’ll walk you through the features of each of these options and compare their build ecosystems, editor tooling, and javascript interop. In addition, as is my habit, I’ve written up a small example in each of these languages. (Well, actually, I’ve taken one of Elm’s small demos and re-created it in the other two). I’ll discuss my impressions of the tooling and the coding experience along the way.

OCaml for the impatient

Mon, 28 Aug 2017 00:00:00 +0000

Ocaml is a rad language with some regrettably underdocumented parts. Or, perhaps, overdocumented – since OCaml attracts people who are interested in rigorous correctness, what documentation exists tends to be rigorous and correct, and also tedious. This guide will be none of those. Let’s go!

Best Practices for Javascript Library Versioning

Sun, 13 Aug 2017 00:00:00 +0000

I spend most of my time on this blog talking about Clojure, but IRL I work on a lot of projects written in a lot of languages. Lately, much of my time has been spent writing and maintaining React-based frontends in Javascript.

As far as I can tell, no language has solved the problem of dependency management. Some libraries are better than others, but upgrading dependencies is always an uncomfortable experience. That being said, I’ve never experienced more pain doing so than in Javascript’s ecosystem.

Domain modelling with clojure.spec

Sun, 06 Aug 2017 00:00:00 +0000

Clojure.spec is, among other things, Clojure’s official answer to tools like Typed Clojure and Plumatic’s Schema. It represents an attempt to apply some validation to data and functions, without compromising Clojure’s dynamism and data-is-data philosophy. In this post, I’ll be working through a sample program by first outlining and modelling it with the help of clojure.spec, then using spec to guide me while I develop the implementation.

What programming language should I learn? (2017 edition)

Thu, 23 Mar 2017 00:00:00 +0000

I occasionally find someone asking this question in my inbox. I’ve learned that for every person that bothers there are a bunch more with the same question, so I thought I’d take a break from relentlessly plugging my side hustle Later for Reddit to answer it publicly.

On Advice (featuring just one piece of it)

Fri, 04 Nov 2016 00:00:00 +0000

I’m perfectly comfortable making wild assertions about which programming technique is better than which other one, but when it comes to handing out general life or career advice, I’m a lot stingier than your average blogger 1. Even if I was wildly successful (I’m not), it’s so difficult to tell, even in retrospect, the difference between the stuff that actually mattered and the stuff that seems like it did but doesn’t 2.

Basic site monitoring with Riemann

Tue, 23 Aug 2016 00:00:00 +0000

Riemann is a general-purpose event processing system, but its most typical application is as a place to send and generate metrics about applications. I recently set up a Riemann server for my personal projects, and I feel like my devops game is stepped up by 1000%.

Or, at very least, I feel like I know know about it as soon as one of my sites goes down.

What’s in a namespace?

Fri, 15 Apr 2016 00:00:00 +0000

Every well-behaved clojure source file starts with a namespace declaration. The ns macro, as we all know, is responsible for declaring the namespace to which the definitions in the rest of the file belong, and generally also includes some requirements and imports and whatnot. But today (at Clojure/West, shoutout!) Stuart Sierra made a passing reference to the internals of ns during his talk that got me interested.

But what is a namespace really?

Write and deploy your own self-hosted Readability clone

Tue, 29 Mar 2016 00:00:00 +0000

Readability.org is a handy tool, but it also suffers from being useful, popular and free – the service is (understandably) often down, or slow. If you’re a heavy Readability user, it might interest you to know that there exist many software libraries that attempt to recreate Readability’s main function – pulling the main body of text out of a page laden with ads and other distractions. Some of these work better than others, but Mozilla’s Readability.

Composible Architecture: A real-world example.

Sun, 27 Mar 2016 00:00:00 +0000

I am the primary maintainer of a significant REST API written using Flask-Restful. Flask-Restful is a pretty full-featured library for creating REST frameworks with Flask. It features everything you need to manage routing to class-based resources, a library for marshalling objects to JSON format, and reqparse, an argparse-inspired library for writing input parsers.

React.js in the small

Sat, 26 Mar 2016 00:00:00 +0000

I’m a big fan of accessible technologies. I get suspicious whenever I encounter a framework or library that is “not worth it for a small project,” because that is a coded statement that means either “It has a broad scope of features that a small project won’t take advantage of,” or “it trades off simplicity or user experience for performance or other reasons.” Accessibility also helps open-source projects move from obscure to ubiquitous; if jQuery had required a command-line tool to compile it when it came out, I can practically guarantee you wouldn’t have ever heard about it.

The Web is (finally) a mature platform

Sat, 19 Mar 2016 00:00:00 +0000

I started my career as a “web developer” circa 2007. I’d dabbled before with Javascript while making sites in HTML/CSS as early as middle school, but that was my first real job as a real software developer. Back in those days, LAMP (Linux/Apache/MySQL/PHP) was about the only sensible way to build a web application. You could use Java servlets, of course, or build applications using CGI, but once PHP was stable and available and straightforward, and it quickly became the obvious choice for a huge range of applications.

Clojure SQL Migration Libaries

Sun, 28 Feb 2016 00:00:00 +0000

It is generally recommended, if you’re developing an application that uses a database, that you manage changes to the schema of said database using some sort of migration system or another. Luckily, several intrepid developers in the clojure community have stepped up with their own solutions to this problem – all of which end up being very similar indeed. Read on for an overview of your options and to find out which one is right for you.

Plotting Reddit post frequencies with d3

Sat, 20 Feb 2016 00:00:00 +0000

This week I added a better graph to Later (for Reddit)’s post timing analysis page. Previously, the most common time and the most common day were plotted on separate bar charts. However, I noticed that I got called out on this in this article on Medium, which offered a pretty sensible alternative that I wasted no time in ripping off wholesale. I still have the bar graphs in, but I also added a 7x24 color-coded grid plot, allowing for a more accurate view of exactly when the most popular posts were posted.

Failjure: Exception-free error handling for Clojure

Sat, 30 Jan 2016 00:00:00 +0000

I’ve written before about handling errors in Clojure without using exceptions, by making use of ad-hoc monads. In that post, I also referenced Andrew Brehaut’s error monad implementation.

Since then, I’ve written a number of projects that use similar handling, and I thought the time had come to wrap it up in a library, which I’m calling Failjure.

Clojurescript Boot Live-Reload Weasel Vim-Fireplace Piggieback

Mon, 11 Jan 2016 00:00:00 +0000

My long-standing complaint about Clojurescript is that it’s a pain to get running. People who prefer Leiningen seem to have gotten a handle on this with figwheel; however, those of us who have jumped on the Boot train (it’s newer and therefore better!) still have to do some assembly to get the live-reloading auto-compiling repl setup that’s become the standard for Clojurescript development.

Like many problems in the Clojure universe, this is less a problem of technology and more a problem of approachable documentation. With just a little bit of configuration and some understanding, you too can assemble that perfect Clojurescript dev setup using Boot.

Deploying a Clojure web app with Pallet

Mon, 04 Jan 2016 00:00:00 +0000

Pallet is a Clojure DevOps platform/library designed to automate blah blah blah. We all know what these things are supposed to do, the question is how they do it, and Pallet takes the agreeable tack of just being a Clojure library that you can run in a repl and do devops stuff.

Clojure SQL library showdown

Mon, 28 Dec 2015 00:00:00 +0000

When it comes to database access, I’ve become less particular over the years as I’ve gotten more and more comfortable with SQL. These days I’m happier to write the SQL to get just the thing I want, than wrestle with an ORM to produce the same thing. Nevertheless, there’s something to be said for abstractions over SQL, and they seem to have lasting popularity. In this post, I’ll compare a few popular SQL DSLs for Clojure, and contrast them all with their mutual pappy, clojure.

Password Authentication/Authorization for Clojure

Thu, 17 Dec 2015 00:00:00 +0000

In my previous post, I gave a quick overview of how the Buddy auth library for Clojure. Today, I’ll give a more fleshed-out example of how to use it to add session-based password authentication to an app.

Clojure auth with buddy

Tue, 15 Dec 2015 00:00:00 +0000

A while back, I wrote about using Friend to handle auth in Clojure. I neglected to mention (or look at, in particular) the other auth framework making waves in the Clojure community, aptly named Buddy.

Buddy is, well, another authentication/authorization framework. It also contains some lower-level crypto utilities, but the main use right now seems to be handling auth for web applications in Ring. I had heard good things about how Buddy works, so I decided to give it a try, and now you get to hear about that.

Using Letsencrypt with Nginx

Fri, 04 Dec 2015 00:00:00 +0000

Letsencrypt.org has just entered its public beta period. This means that you can get ssl certificates really easily and for free. Letsencrypt’s certificates are up to modern specs and fully accepted by all browsers, so you no longer have any excuse not to have SSL on all your domains.

This post will hold your hand through the process of moving your Nginx site from http to https.

Introducing Unpythonic

Mon, 19 Oct 2015 00:00:00 +0000

A short post to say that I’ve just launched a new project called Unpythonic. It’s a collection of articles introducing various concepts and techniques for functional programming in Python.

Writing Friendlier Clojure

Thu, 01 Oct 2015 00:00:00 +0000

I love the Clojure language, but I don’t think there’s any use pretending that the combination of expressiveness, power, and repl-driven development can result in some staggeringly dense code. Everyone that writes Clojure is guilty of this at one time or another; you start with the core of your function, evaluate it, wrap it a bit, eval again, and before you know it you have a lopsided, deeply nested, organically-grown stalagmite of a program.

React.js for incremental text games

Sun, 12 Jul 2015 00:00:00 +0000

I have a small weakness for silly text games like Candy Box and A Dark Room, and most recently Kittens Game (“a Dark Souls of incremental gaming”). The common feature of these games is that, for the most part, the UI is just numbers on a web page, and you perform certain actions to increase those numbers to purchase upgrades that further your ability to increase the numbers.

One of the great things about this style of game is that the barrier to entry is very low (which is probably why there are approximately a brazilian of these things around), and the games in the genre are differentiated almost solely by the quality of their mechanics (without silly things like “art” to get in the way). You, the reader, might even be interested in dipping your toe in the world of incremental games. If you want to add one to the pile, I recommend you use React to do it.

Ripping off Circular.io in Clojure

Mon, 15 Jun 2015 00:00:00 +0000

Circular.io is a clone of Buffer, or at least the Buffer of about 5 years ago. Back then, all buffer did was let you schedule posts to Twitter, to be sent at regular intervals throughout the day. It was on HN about 3 years back, and has been running since then. And people really use it! They’ve done a great job with their little app, and the fact that it’s open-source means that for the purposes of this post, we can steal their frontend and just install a new backend.

Easy custom auth in Clojure with Friend

Wed, 10 Jun 2015 00:00:00 +0000

I’ve used friend to provide auth in my projects a few times, and considered it many more before resorting to my own hand-rolled business. Most of the reason for this is that is just seems so complicated. Workflows? Credentials? I just want to check a password and stash a user object in the session, end of story. After I did some investigating, though, it turns out that you can usefully deploy friend for even very simple workflows, if you understand how it works.

Throwing together a weekend project with boot-clj

Mon, 08 Jun 2015 00:00:00 +0000

This weekend I made http://worldclassifiedlist.com on a whim. Past experience suggests that I’m not likely to derive any value from the site itself, so before it’s completely forgotten, overlooked by an indifferent world and relegated to an unnoticed screenshot on my portfolio page, I thought I might wring a few ideas out of the making-of.

Building a graph-powered suggestion engine for redditlater with Loom

Sun, 07 Jun 2015 00:00:00 +0000

Besides the post scheduling, the main reason people come to http://www.redditlater.com/ is the subreddit analysis feature. This lets folks enter in a subreddit and tells them when the best time to post on a given subreddit is.

Little do they know, it tells me about them, too.

My first time using boot over leiningen

Fri, 05 Jun 2015 00:00:00 +0000

When boot first appeared in my usual rotation of clojure news, I must confess that I didn’t really see what the fuss was about. It seemed like someone had taken leiningen and broken out all its parts into functions, which you could then use to get your dependencies, build your project, and so forth. Don’t you see! Leiningen is just a build tool, but boot could be anything. It could even be a build tool!

My favorite old webdev tools

Thu, 09 Apr 2015 00:00:00 +0000

The way we make websites has changed a lot since I started doing it, and it’s important to keep up-to-date on new tools and techniques. That said, I’ve been noticing that I’ve not spent as much time churning through new frameworks and whatnot as I used to – in fact, I’ve picked out a few tools that I’ve been using for years.

Interfacing Frege and Ring

Sun, 21 Dec 2014 00:00:00 +0000

Frege is a strongly-typed functional language for the JVM. Its goal is to mirror Haskell as closely as is possible on the platform, and as far as I can tell it does a pretty decent job. It seems performant enough, and more importantly grants access to a Haskell-esque type system. This makes it a pretty good complement to Clojure for those problems where a strong typing system is important.

The downside to Frege is that, even though documentation exists (and is actually quite expansive given the language’s limited adoption), it’s still hard to find straightforward how-tos by googling. So here’s some much-needed frege-related blogspam to fill out those results.

Implementing multimethods in Python

Thu, 11 Dec 2014 00:00:00 +0000

In Clojure (and many other languages), a multimethod is an implementation of multiple dispatch as an alternative to single dispatch.

Traditionally, if you define several methods with the same name on different classes, the type/class of the first argument (in Python, self, in many other languages implicit) is used to pick which method to call. This is called “single dispatch” because the decision of which method to call is left up to the inferred type of a single argument.

Multimethods take the approach of leaving the dispatch up to the user; you can dispatch on any value at all. You just need to supply a function that returns the value on which you wish to dispatch, and a method for each possible value. For certain cases, this is a lot more flexible than single dispatch.

Functional vs Object-oriented approaches to validation

Sun, 07 Dec 2014 00:00:00 +0000

Functional programming is often described in terms of its contrast with object-oriented programs; that is, you write functions that act on data instead of objects that wrap data and use methods to act on themselves. Functional programming wonks (like me) will tell you that writing code this way is generally better than OO, but I don’t want to do that (right now).

However, in this post, I’m not here to argue either side. Today, I’m just going to demonstrate a few equivalent approaches to the same problem: validating data.

Back from Clojure Part 1: Python

Mon, 01 Dec 2014 00:00:00 +0000

One of my favorite genres of article to write are the ones that involve refactoring some code to make it more functional, and (hopefully) improve it on the way. With that in mind, I’ve decided to embark on a tour of some of the things users of other popular dynamic languages can take away from the ideas behind Clojure, even if they never use it themselves. Today, I’ll be taking an old Python library I wrote and refactoring it to fit a few ground rules.

My life as a homeless transient.

Thu, 27 Nov 2014 00:00:00 +0000

I hate the term “Digital Nomad”. Whenever I see it in the context of an article or blog post, it reeks of pretension and better-than-thou-ness – which, I rush to point out, is not a vibe I ever get from actually talking to fellow travellers in person. Usually, when I meet someone who asks about my lifestyle, I just laugh and say I’m homeless but employed.

Whatever you want to call it, a life of permanent travel seems to have a broad appeal, at least with some segment of society. And, as such, it’s something I occasionally get asked questions about. Today, I’ll answer questions that I haven’t been asked, but feel free to ask more in the comments and I’ll answer.

Clojure is still not for geniuses

Mon, 24 Nov 2014 00:00:00 +0000

The inspiration for the article I wrote last week entitled Clojure is not for geniuses was inspired by Tommy Hall’s talk at Euroclojure 2014, wherein he made an offhand joke about preferring Clojure for its minimal syntax, as he possesses a small brain (both his blog and his head suggest this assertion is false). I had intended to bring this up with the original article, but got sidetracked talking about immutable things and never got back around to it. Here I’d like to address that, along with some discussion that arose in various forums after the first article.

Clojure is not for geniuses

Tue, 18 Nov 2014 00:00:00 +0000

It’s a common attitude that functional languages with immutable collection semantics, such as Clojure, are for a) pretentious language geeks, or b) actual genius programmers. I’m in no position to defend against point a) given the body of my writing on this blog, so today I’d like to write an article about point b).

What language should you learn?

Thu, 30 Oct 2014 00:00:00 +0000

I travel a lot these days. I’d call myself a “digital nomad” as a shorthand, if there was any way to say it without sounding impossibly smug. Let’s just say I’m homeless but employed and my wife and I live in AirBnbs.

One of the challenges of moving around so much is dealing with language barriers. For the most part, even in places where English isn’t widely understood, it’s perfectly possible to get whatever you need with gestures, chief among them pointing and holding up money. It’s the little things that are harder when you can’t speak the language.

A clojure cup retrospective

Mon, 29 Sep 2014 00:00:00 +0000

Update: Voting is live! Vote for my app at https://clojurecup.com/#/apps/booker, then check out some more deserving entries at https://clojurecup.com/#/apps and vote for them too!

I’ve just spent about 30 hours this weekend coding up Booker, my entry to the 2014 Clojure Cup, in which I participated as a one-man team. It was pretty exhausting, and the app doesn’t do quite as much as I was hoping it might, but I’m still quite happy with how it all turned out. Here’s how my weekend went.

Compojure apps, in the style of Sinatra

Fri, 05 Sep 2014 00:00:00 +0000

Clojure has an approachability problem. In part, this is due to the relatively unusual syntax, but that can’t get all the credit. When it comes to building server-side web applications, a major sticking point is the “lack of frameworks” problem, and more to the point, the common Clojurian’s response:

“Clojure users prefer to assemble their own stack from small, composable libraries.”

Deploying a Clojure web app to a VPS

Thu, 28 Aug 2014 00:00:00 +0000

So you wrote an app. Great! Next step is to put it somewhere where people can use it. This tutorial will walk you through the process of deploying your app.

Using Kotlin from your Clojure projects

Sat, 23 Aug 2014 00:00:00 +0000

Problem: You need to extends some Java interface or class to use some Java API, and for some reason Clojure’s java interop tools are too unwieldy to do it cleanly.

A url shortener service in 35 lines of Clojure

Fri, 22 Aug 2014 00:00:00 +0000

I saw this post by Grasswire today, and I couldn’t resist the urge to throw down a Fizz-Buzz-pocalypse. So, here’s my implementation in Clojure, along with a list of ways that Clojure clearly wins. (That last sentence was to be read tongue-in-cheek, Scala is a good language too. Besties!).

Using Parquet + Protobufs with Spark

Wed, 20 Aug 2014 00:00:00 +0000

I recently had occasion to test out using Parquet with protobufs. I got some simple tests working, and since I had to do a lot of reading to get to this point, I thought I’d do the world a favor and document the process here.

Embedded MapReduce with Flambo

Mon, 18 Aug 2014 00:00:00 +0000

I recently stumbled across a neat library called Flambo. Flambo is a clojure wrapper for Spark, and it does a really great job keeping everything nice and Clojure-y. I wanted to show you so you can enjoy it too!

Ten reasons to use Clojure/ClojureScript on your next web dev project

Fri, 15 Aug 2014 00:00:00 +0000

Hello sir. I’m here to talk to you today about accepting Clojure into your workflow. Do you have a few minutes? I’d like to show you these ten ways that Clojure can help you make better software. Good, here we go!

A simple Clojurescript app

Wed, 13 Aug 2014 00:00:00 +0000

In May, I left Canada to do some long-term travelling with my wife. I don’t mention it here because this isn’t tumblr, but it does mean that I have some problems many people don’t, such as figuring out when I can return in the Schengen Area. This is a problem that has been solved, but I’ve yet to see it solved well, so I decided to build my own calculator as an exercise using Kioo with Om.

Top Github Languages of 2014 (So far)

Fri, 01 Aug 2014 00:00:00 +0000

It’s that time of year again! Today, we’ll look at just over a half-year’s worth of Github data to draw unsubstantiated conclusions about the relative popularity of programming languages. Ok let’s go!

My Top Clojure Articles

Mon, 07 Jul 2014 00:00:00 +0000

For the past few years, most of my posts have been beginner-intermediate essays on various clojure features and coding techniques. Since a lot of people have told me that they like my blog as a genre piece, I decided to pull some of my favorites into one place, and order them by difficulty, from Clojure beginner on up so that folks don’t have to root around.

5 mistakes I made writing my first Clojure application

Wed, 02 Jul 2014 00:00:00 +0000

It’s been about two years since I undertook my first sizable application in Clojure, and really my first experience architecting a system in a functional language. It was a local dating application, and it’s still up and running, despite the sins below. But, reading the code now, a few dire instances of truely bad code emerge. So, I crawled through for some examples, which I now impart to you:

DIY NoSQL part deux: interchangeable parts

Mon, 30 Jun 2014 00:00:00 +0000

After my last post on using Clojure’s STM as a quick-and-dirty in-memory datastore, I had an interesting discussion in the comments about the wiseness of implementing my example with a static global. Coincidentally, I attended a talk by Stuart Sierra at EuroClojure about this very thing, and started getting some ideas about how to make things better, which I want to share today.

Java to Clojure: "Refactoring" refactored functionally

Tue, 10 Jun 2014 00:00:00 +0000

I was searching for a good example to illustrate some properties of refactoring object-oriented code into a more functional style, and I came across this example from Martin Fowler’s Refactoring. It describes the process of refactoring code for a video store. It’s a nice little example with a useful narrative to go along with it.

"DIY NoSQL" in Clojure

Mon, 02 Jun 2014 00:00:00 +0000

I saw this post, “Do It Yourself NoSql”, recently, and it reminded me of something that Clojure does very very well.

Clojure’s go-to concurrency enabler is its STM system: atoms, agents, and refs. I’ve written about it before, but this seemed like an opportunity to provide a nice example, and discuss a little more about some of the things I often do to defer the need for a database.

The nitty-gritty of a Clojure web app

Wed, 14 May 2014 00:00:00 +0000

This post is a follow-up/supplement to my article Anatomy of a Web App: How I Built RedditLater in Clojure, published on sitepoint. To make the article appealing for a mass-market audience, I had to take out most of the nitty-gritty details that wouldn’t interest people who weren’t interested in Clojure to begin with (plebians!). The details still have some good stuff in them, though, so I’ve made this post out of it.

So I hope you’re here to read about my fiddly minutae, because off we go!

In Defense of Coffeescript

Sun, 06 Apr 2014 00:00:00 +0000

I often see arguments about whether or not using coffeescript is a good idea. Arguments against usually center around whether it’s a barrier for contributions, or whether it’s an unnecessary abstraction over another language that the developer needs to know anyhow.

Elasticsearch Rosetta Stone

Thu, 20 Mar 2014 00:00:00 +0000

I’ve recently done some work with Elasticsearch. It’s a great platform, but I still found it pretty hard to get started. It wasn’t obvious what was what. Perhaps I didn’t read the docs closely enough. Anyhow, I wrote up some examples demonstrating how to get started with Elasticsearch.

Set up Flask with webassets

Thu, 20 Feb 2014 00:00:00 +0000

Flask isn’t new, but it’s really great, and it’s definitely my first choice when starting a new Python app. Today I want to give you a quick tour of the tools I use to set up a new Flask app.

Just what does "code as data" mean anyway?

Sun, 19 Jan 2014 00:00:00 +0000

Recently, I’ve seen popular articles on macros and metaprogramming in Nimrod and Elixir. Both of these are wonderful metaprogramming systems, to be sure, but I couldn’t help but imagine some in the audience smirking inwardly – and occasionally less inwardly. What odd syntax! How out-of-place they are! If only there existed a homiconic language, they think sarcastically, that could eliminate the need for awkward and forced syntax. Of course, these smug bastards are users of any of the LISP family of languages.

The many flavors of concurrency in Clojure

Fri, 06 Dec 2013 00:00:00 +0000

Clojure, being the extensible, malleable, rewritable language that it is, is spoiled for choice when it comes to making your cores work for you. You can pick your poison when it comes to making your program concurrent.

Angular in the small

Sat, 16 Nov 2013 00:00:00 +0000

For those of you that aren’t familiar, Angular.js is one of a new breed of emerging frameworks dedicated to building rich, responsive in-browser interfaces. I’ve had the privilege of working with both Ember.js and Angular.js, and enjoyed them both, so this won’t be a showdown (if that’s what you came for, here’s a nice one).

Common Rules in Cryptography

Thu, 07 Nov 2013 00:00:00 +0000

Disclaimer: I have no background in cryptography, despite writing occasional ramblings on the subject. I just know what I’ve picked up along the way, of which precious little is made available to people who don’t go searching for it.

What your datastore says about you

Tue, 08 Oct 2013 00:00:00 +0000

Disclaimer: Do I even need a disclaimer? Chill out dudes, don’t get all bent.

Clojure's core.typed vs Haskell

Sun, 29 Sep 2013 00:00:00 +0000

Ambrose Bonnaire-Sergeant’s core.typed library has been receiving a lot of attention lately. In fact, Ambrose has just raised a well-deserved $20,000 to continue his work on the library.

On secure SSL: The least every developer should know

Tue, 10 Sep 2013 00:00:00 +0000

The NSA, besides playing the role of Big Brother in the unfolding dystopian saga revealed by Snowden’s leaks, is at the forefront of cryptography research. Being in the business of secrecy, the NSA also has recommendations for keeping things secret. The first of these, Suite A is naturally a secret, and apparently recommends a mysterious list of algorithms known only to the NSA. However, their Suite B recommendation for general national security use is published as an RFC, and suggests technologies available today in browsers and web servers.

Top Github Languages for 2013 (so far)

Fri, 30 Aug 2013 00:00:00 +0000

I just discovered the Github Archive, a dataset of Github events queryable using Google BigQuery. What fun! So I decided to count how many repositories have been created this year by language.

Fixing "Could not generate DH keypair" on RedditLater.com

Wed, 21 Aug 2013 00:00:00 +0000

RedditLater.com is a little app I made last April. It worked fine until sometime in July, when Reddit released an improvement to its SSL configuration on its api. Thereafter, attempts to get an access token using clj-http-lite began to fail with a javax.net.ssl.SSLException: Could not generate DH keypair exception. Some investigation led me to a stackoverflow post (where else) which led me to this eventual workaround: hack up clj-http-lite to wrap the default SSLSocketFactory in a new class that would remove all the unsupported algorithms from the list of supported ones.

3 new programming languages to watch

Tue, 06 Aug 2013 00:00:00 +0000

On the eve of learnxinyminutes.com getting TechCrunch’d, I thought I’d write about a few of my favorite languages on the site. Learn X in Y minutes has a lot of conventional blockbusters like C and Java now, as well as old cult favorites like Haskell and Erlang, but it was the independent films — that is, languages — that received some of the earliest attention, occasionally by their creators themselves. Being the language-dabbler/compulsive HN reader that I am, I had already heard of them, but in case you haven’t, here are three cool new languages that you can stuff in your brain hole:

3 Wrong Ways to Store a Password

Thu, 11 Jul 2013 00:00:00 +0000

Sooner or later, in the field of Web Development, you’re going to need to store someone’s password. This is easy to get wrong, but easy to get right, too. Today, let’s take a tour of the wrong ways, and then find out how to do it the (current) right way. Plaintext Alice just learned PHP, and are making an app with user authentication. Her database stores an email and password in a table called users.

Live development is the way of the future

Wed, 10 Jul 2013 00:00:00 +0000

Live development is nothing new; it’s been well-explored in Lisps and in other languages like Smalltalk and Erlang since more or less the dawn of man. Emacs was for a long time – and by many still is – considered the only way to develop for Lisp, thanks to SLIME. But I with projects such as Light Table, and a growing popularity of functional and dynamic languages in general, I think we’ll see live coding become seriously popular as capable mainstream tools collide with capable mainstream languages.

Reducers explained (through Python)

Sun, 07 Jul 2013 00:00:00 +0000

Last year, Clojure introduced a new library called core.reducers, which represented a new, efficient way to deal with operations across collections in functional languages. It’s since been picked up by Elixir, and libraries have been written for some other languages.

Today, I want to explain a bit about what reducers are, why they exist, and how they can be more efficient than other functional methods of handling collections, and help you write your code more prettier.

Learn C in Y minutes

Fri, 28 Jun 2013 00:00:00 +0000

Learn the language of strong, independent women and hairy-chested manly men alike: I’ve written a quick C overview for LearnXinYMinutes.com. Y probably is not 15 in this case, but if you feel like brushing up, head on over to http://learnxinyminutes.com/docs/c/ and learn you some real programmin’. I’m not sure how applicable the format is to a language with as many tricks up its sleeve as C has, but feel free to tell me what you think!

Learn X in Y Minutes

Wed, 26 Jun 2013 00:00:00 +0000

Short version: Go to http://learnxinyminutes.com/

After I posted Learn Clojure in 15 minutes, perhaps yesterday, itself a knockoff of Tyler Neylon’s Learn Lua in 15 minutes, I had a little twitter brainstorming session with Tyler and @emarref. Therein, I was inspired/encouraged to generalize the concept of inline tutorials-as-code language primers in a community-editable site.

Learn Clojure in 15 minutes, perhaps

Mon, 24 Jun 2013 00:00:00 +0000

Moving on from pointless flamebait rants, here’s something a bit more constructive. Inspired by Tyler Neylon’s excellent Learn Lua in 15 minutes, I humbly present my original effort at an equivalent for Clojure (also available as a gist).

You use PHP because you don't know better.

Wed, 19 Jun 2013 00:00:00 +0000

My typical response when asked to defend a given offhand, derogatory comment I’ve just made about PHP is to cite the most excellent PHP is a fractal of bad design. But, spurred, by the numerous comments hating on me for hating on PHP on this Portugese translation of my PHP vs Python vs Ruby vs Clojure piece (which, to be fair, is emphatically biased), I’m going to go ahead and let the hate out now, as one big rant, so that I have something to refer to in the future (even though I bet I’ll find it embarrassing and childish then).

Clojure.core: Batteries (almost) included

Thu, 13 Jun 2013 00:00:00 +0000

Today, I want to provide a guided tour through some of the many libraries available from the Clojure team that don’t come distributed with Clojure. Consider them Clojures standard library. Some came from old clojure.contrib libs, others are brand-new, but all are great.

Structured Clojure: Protocols and multimethods (oh my!)

Tue, 04 Jun 2013 00:00:00 +0000

You can use Clojure to do just about anything without ever needing to define anything but functions and vars, but you’d be missing out. Clojure supports some very nice ways to make your code more expressive – and more structured – when dealing with operations on data types.

Improving your Clojure code with core.reducers

Mon, 27 May 2013 00:00:00 +0000

Clojure is developed, maintained and documented by a cadre of extremely brainy people. This is mostly excellent news for users of clojure, but sometimes, I find myself feel a bit left behind reading about features and details of the language, especially coming from a background of procedural languages. Last year I read Rich Hickey’s blog post on Clojure’s new reducers library. My takeaways on reducers at the time were thus:

Big wins: Multi-armed bandit testing.

Wed, 22 May 2013 00:00:00 +0000

I’m all about big wins. I could care less about incremental optimizations if there’s a major victory to be had instead. That’s why I’m way into multi-armed bandit testing right now.

Idea: Device-specific screenshots (or, Abusing Retina.js on Addressbin)

Sun, 19 May 2013 00:00:00 +0000

In January I came into possession of a new retina-display Macbook Pro. The screen is amazing, but has the side effect of making images on websites look mostly like garbage, unless the developer has taken extra steps to serve double-sized images to people with fancy screens. I ran across this problem trying to put a screenshot of Outlook on the homepage of Addressbin.com, my latest project. I knew it looked fine for almost every other visitor, but it was jarring for me, and presumably to anyone with a retina screen.

"Good Enough" error handling in Clojure

Mon, 13 May 2013 00:00:00 +0000

Writing Clojure is not like writing Java. In Java, exceptions are an accepted part of the workflow; in Clojure, they are begrudgingly supported out of necessity, but generally avoided. Why is that? Probably because writing code that throws exceptions makes your functional code a lot less functional – that is, a lot less composable. When you can’t trust a function to execute and return a value you lose some functional purity.

Clojure web apps: Zero to 'Hello World' on Heroku in Clojure in 15 minutes.

Sun, 07 Apr 2013 00:00:00 +0000

I’ve been talking a lot about Clojure lately, but the pool of people who want to listen is pretty small. I know, I know, it’s pretty different, but I promise it’s really cool – maybe even better than the languages you already know – once you get to know it. So today I want to step back to the very basics by outlining how to get a Clojure app up and running, and maybe produce some more Clojurenauts in the process.

Why Clojure? Part 2: Effortless async by design

Fri, 05 Apr 2013 00:00:00 +0000

As a second part in what I’ve decided will be a series attempting to justify my choice of Clojure as a general-purpose web language, I’d like to talk a little bit about writing asynchronous code in Clojure, and just how easy the design decisions made by Mr. Hickey make that.

Middleman + Enlive: The best thing since PHP

Tue, 02 Apr 2013 00:00:00 +0000

Before I begin, the ideas in this article were introduced to me by this blog post, which I consider a must-read for anyone who uses Clojure on the web.

I’ve been using Clojure for web development a lot more lately. This can be a contentious topic for some people. “Clojure is hard to hire for”, they say. “It’s for pretentious nerds”. “It’s overkill for the web”.

The same app 4 times: PHP vs Python vs Ruby vs Clojure

Mon, 25 Mar 2013 00:00:00 +0000

Here’s a toy program I wrote implemented in PHP, Python, Ruby, and Clojure. I hope it’s helpful for someone who knows at least one of those and wants to learn another.

Cover Letters: Then and now

Thu, 28 Feb 2013 00:00:00 +0000

I was told the other day that my communication style (as interpreted by cover letters I sent) had changed dramatically for the better over three years. Thanks for that! So I thought I’d share in hopes of helping someone else do the same.

Trending: The iOS Stock Viewer that's better than the stock viewer

Thu, 03 Jan 2013 00:00:00 +0000

Trending, by Tapfolio, is an iOS app for tracking stocks, available now on the app store. It makes viewing your stock portfolio’s current pricing a snap, and sorts on most changed so you always see what you want to know about. Also, I just started work at Tapstream, a company which may or may not be affiliated with Tapfolio. It seems pretty rad, and I’m really looking forward it.

Welcome to the blog, mark III

Fri, 21 Dec 2012 00:00:00 +0000

Welcome to the new blog. I hope you like it, I made it myself.