Git is a distributed version control system (DVCS) that we use every day to manage our code. It is a powerful tool but have you ever wondered how it works its magic? The Git internal docs can be intimidating, incomplete, and don’t have examples. Digging through the Git’s implementation can also be intimidating, particularly if you aren’t familiar with C. Pulling apart the engine and putting it bac

The power of React Hooks allows us to manage reusable and composable state in our React components, without the need for class components or global state (such as Redux). Combining that with the flexibility of TypeScript interfaces, there are several different methods we can use to model our component state and context in a type-safe way. In this post I will illustrate some of the benefits to usin

I was recently working on an application in which we had a class method / scope used to return a specific set of users. This was fine and good until we found ourselves needing to capture the same logic at the instance level. Ideally, I was hoping to be able to avoid duplicating the logic, and simultaneously keep things efficient. Users in our application can be configured to receive alerts. We hav

Maybe has a tendency to take over your codebase. This property is sometimes described as being viral. Uncertainty begets uncertainty. This sort of defeats the goal of using Maybe in the first place: give you confidence in the presence of most values. By slightly changing our approach to solving problems involving uncertainty, we can contain Maybe to those parts of our code that are truly optional.

Our world is full of uncertainty. This uncertainty bleeds into our programs. A common way of dealing with this is null/nil. Unfortunately, this leads to even more uncertainty because this design means any value in our system could be null unless we’ve explicitly checked it’s presence. Constantly checking the presence of every value is a lot of work so we tend to only check the riskiest places and

SVGs can be messy to develop with, often times being exported from a graphics application and being pasted into a document. However, they become much more delightful to work with when you have a readable file and clean markup. Optimizing SVG for the web When an SVG is exported from an application, it usually comes with code that’s unnecessary for rendering it on the web. For example, in Sketch, th

Photo by NCWRC and courtesy of Ohio University. Licensed CC-BY-NC. Cocaine was originally extracted from how Paperclip handled shelling out its commands to ImageMagick. I named it “Cocaine” because, one, I really enjoy puns and, two, I fully didn’t expect anyone else to use it. But, as they say, no matter what you assume, people will do something differently. Is that what they say? Anyway, point i

Lucky catches bugs, returns responses quickly, and helps you write maintainable code. Lucky’s actions help you to process requests and return responses as reliably and productively as possible. To make Lucky actions rock solid, we looked at the problems we often experience while building apps. Problems that we wanted to solve with Lucky These issues often slow down development or cause embarrassin

These days, most Rails projects use some form of factories in their test set up. What problem do they solve and why are they needed? Too much info Given a User model with first_name, last_name, and location fields, we could write a test like: describe "#full_name" do it "combines first and last name" do user = User.new( first_name: "Joël", last_name: "Quenneville", location: "Boston" ) expect(user

In July of 2017, CircleCI released their new platform, 2.0. It’s much more powerful and flexible, but it’s also more complex to get up and running with for Rails apps. Let’s walk through it… A Base Configuration The CircleCI configuration file is now in .circleci/config.yml. Initially, it should start looking something like this: --- version: 2 jobs: build: working_directory: ~/your-app-name steps

While adding Credo as supported linter on Hound, I ran into a problem that I hadn’t seen before. I needed to run mix credo in a temporary directory, but soon discovered Mix only searches the current directory for a .mix.exs. What this means is that you can only run mix from the root of your project if you depend on any configuration or dependencies in your mix.exs file. In most cases this isn’t a

For a while now, we’ve recommended against using let in RSpec and minitest. We even have a blog post explaining our thoughts. Despite that, I still have trouble explaining my problems with let and before to other developers. They’re wonderful for cleaning up duplication, and can make your tests smaller. That has to be a win, right? Maybe not. Let’s talk about some of the pain associated with using

The latest big ActiveRecord feature to Rails has been polymorphic associations. Not very clear at first, I found out they’re easier to understand with a couple examples. A common one: class Person < ActiveRecord::Base has_one :address, :as => :addressable end class Company < ActiveRecord::Base has_one :address, :as => :addressable end class Address < ActiveRecord::Base belongs_to :addressable, :po

ActionCable was introduced in Rails for its 5.0 release as a way to seamlessly integrate WebSockets in Rails applications. I was curious to know more about it, and the opportunity presented itself while doing a React frontend to a Rails API. How could we interact with it with plain Javascript? ActionCable basics By allowing easy use of WebSockets on any Rails codebase, ActionCable adds real-time c

Back in 2015, we announced the public beta of a book on roguelike development using Ruby. Unfortunately, a lot has happened since then, and the project has been stuck for a while. We’ve decided to refund everyone who’d originally purchased it and opensource the project. It’s very exciting to be creating a book with the help of the community! As we write this, the source for the build system is clo

We’re renaming factory_girl to factory_bot (and factory_girl_rails to factory_bot_rails). All the same functionality of factory_girl, now under a different name. Initial Rollout After the rename of the gem, we rolled out version 4.8.2 of all of factory_girl, factory_girl_rails, factory_bot, and factory_bot_rails on October 20, 2017. We decided on a patch-level release because after internal testin

So there’s been a bit of activity on the Paperclip front. I’ve added Amazon S3 support using the RightAWS gem. Some fellow githubbers have contributed some patches to fix up said S3 support, as well as to add more (and better) validations for content type, etc. We’ve brought it up to a nice, round v2.1.2 as of yesterday. Give yourselves a round of applause. I highly encourage you to give it a whir

If you’ve been developing applications in Swift for any length of time, you’ve grown accustomed to often having one or more lines of text at the top of your file. No, I’m not talking about the Xcode generated commented-out metadata when you make a new Swift file (if you’re like me and don’t particularly care for it either, we’ve got you covered) — I’m talking about our friend the import declaratio

Dig deeper into Ruby on Rails. This series of video tutorials will help you move beyond the basics and start understanding and using more advanced Ruby- and creating better Ruby apps. As part of this course you can code along with a thoughtbot’s own Matt Mongeau as he works, fork the repository and get your hands dirty with your own code. You’ll be an intermediate Rails developer in no time - and