# Living Style Guides – Bring the Benefit of Devcards to Any App

One of the big ideas in the ClojureScript community right now is devcards. Devcards are a way to work on the components in your application without having to work in the application itself. Instead of finding your way through the application and manually exercising a component’s possibly many states, you have a page of devcards showing those states.

Devcards are especially useful for component states that aren’t easy to test, such as those seen only by particular kinds of users or at certain times of day. Bruce Hauman has called “increasing the bandwidth of feedback.”
Read more on Living Style Guides – Bring the Benefit of Devcards to Any App…

# Writing Better Commit Messages with Tmux

I’ve been trying to write more detailed commit messages—breaking down what’s happening in big change sets, explaining problems I encountered and how I solved them, pointing out potential weaknesses in the code or future improvements—but it’s not easy to remember all the particulars while staring at the commit message editor.

Fortunately, Tmux can help.
Read more on Writing Better Commit Messages with Tmux…

# An Introduction to Taxicab Geometry

The narrator of Edwin Abbott’s classic Victorian satire Flatland is a commoner, a simple, two-dimensional square. He lives in a two-dimensional world filled with other flat characters: line segments, triangles, higher-sided polygons, and circles.

Circles, in Flatland, constitute the upper classes of society, but if Abbott’s humble narrator had been born in a different flatland, he could have been a square and a circle.

Impossible, you say? Allow me to introduce you to TaxicabLand. Read more on An Introduction to Taxicab Geometry…

# Thinking in Aggregates – Moving Beyond the Singular

Aggregate \Ag”gre*gate\ n. – a mass, assemblage, or sum of particulars; as, a house is an aggregate of stone, brick, timber, etc.

When we first learn a new thing, it’s the particulars that stand out to us. A pre-toddler learning to walk must focus on each and every step. But as we grow, the particulars fade into higher-level ideas and skills. As adults, we rarely think about individual steps; instead, we simply go for a walk.

The same pattern is found in professional fields, such as science. The particulars of orbits and falling things gave way to the aggregate idea of gravity. When scientists first discovered electrons, they imagined them as single, planet-like points orbiting an atomic nucleus. Since then, scientists have given up the idea of point-like electrons, replacing it with the aggregate concept of an electron probability cloud.

The science and art of programming trends the same direction. Read more on Thinking in Aggregates – Moving Beyond the Singular…

# Scripting Vim to Help Run Ember Tests

Years of using the testing framework RSpec has spoiled me. Because you can pass a filename and line number to the RSpec command and it will run only that test, it’s trivial to set up a Vim key binding that runs the test under the cursor. For example,

Read more on Scripting Vim to Help Run Ember Tests…

# The Practice of Practice

Perhaps the most important ability any person can have is the ability to practice, for by it almost everything else is possible.

Since having a daughter, I’ve discovered humans are born with the ability to practice. She practices new skills daily. One day it’s repeating the same sound over and over, another it’s rolling across the floor front to back, back to front. Lately it’s pulling herself to a standing position, then sitting down without falling over. She practices relentlessly, and it’s a good thing too, because practice is the only way she’ll master important skills like walking and talking.

Read more on The Practice of Practice…

# Implementing the Elm Architecture in ClojureScript

The Elm architecture is a simple and straight-forward alternative to the common model-view-controller architecture, and it’s well suited to functional programming.

In brief, the Elm architecture uses a data structure to render a UI, the UI fires actions, and actions are used to update the data structure. This is the same sort of uni-directional flow that React.js uses and the one that Ember.js has been gravitating toward in place of two-way data bindings.

Read more on Implementing the Elm Architecture in ClojureScript…

# Getting the Architecture Right

The foundational building blocks of your software determine what’s easy and what’s not. It’s important to know how the choices you make at the lowest level will affect your ability to build features down the road. When your software architecture doesn’t match the problem domain, it feels like walking uphill. When you get it right, features seem to come together on their own.

Read more on Getting the Architecture Right…

# Domain-Specific Languages vs. Notation

Programming languages often advertise themselves as being well-suited for writing domain-specific languages (DSLs), languages within the programming language that express the concepts rather than the mechanics of the code. Ruby is probably the most popular such language, but many others—such as Scala, CoffeeScript, and Io—also try to make it easy to write code that’s human-readable.

Read more on Domain-Specific Languages vs. Notation…

# Setting Up a Project Workspace in Tmux

As a developer, I spend a lot of time working in the terminal. Besides starting long-running daemons such as web servers in the terminal, I also use Git, Vim, and other command line tools throughout the day, and terminal sessions tend to pile up. On any given day, I can have more than a dozen terminal sessions open at a time, and that’s just for one project. Read more on Setting Up a Project Workspace in Tmux…

Read more on Setting Up a Project Workspace in Tmux…