Charlton Austin

The Dawn of the Strategic Engineer

Thu, 20 Nov 2025 00:00:00 +0000

As the 21st century marches on, technology is no longer just influencing our lives. It is reshaping our world and the way we work. This is especially true in the field of engineering, where AI technologies are transforming not just the work itself, but the very role of the engineer. The introduction of advanced AI technologies has automated many aspects of the engineering process, making tasks easier and boosting productivity. However, this shift also brings about a new challenge for engineers: how to remain relevant and valuable in an era of rapid automation.

Rethinking Supervision and Support in Remote Work Environments

Sun, 21 Sep 2025 00:00:00 +0000

Introduction

As businesses continue to navigate the evolving landscape of remote work, many leaders grapple with the challenges of supervision and support in a virtual environment. Remote workers may feel isolated and disconnected from their colleagues, making it difficult for them to access the support they need to perform at their best. Although some argue that remote work is a failed experiment, others believe that by embracing change and adopting creative strategies, there will be a persistent and growing benefit to companies that embrace remote work.

The Value of Continuous Learning in a Startup Environment

Mon, 14 Jul 2025 00:00:00 +0000

Introduction:

In today’s fast-paced business landscape, one of the key drivers of success for startups is their ability to adapt and innovate quickly. This often hinges on the team’s collective knowledge and skillset, which is why fostering a culture of continuous learning is paramount. In this blog post, I will share my experience as a founder in creating and maintaining a learning-focused environment within my startup, along with the benefits it has brought to my team and our company’s growth.

Unlocking the Power of Diversity in Startup Hiring

Tue, 06 May 2025 00:00:00 +0000

Introduction

In the fast-paced and ever-evolving world of startups, the importance of diversity in hiring decisions cannot be overstated. Building a diverse team not only ensures a broader range of perspectives and ideas, but also fosters adaptability and resilience in changing market conditions. This post will explore the value of diversity in startup teams and provide strategies for building a diverse workforce that can thrive in the face of uncertainty.

Striking a Balance Between Speed and Quality

Sat, 15 Mar 2025 00:00:00 +0000

Introduction

When embarking on a startup journey, finding the right balance between speed and quality is crucial for success. In this blog post, I’ll share my personal experiences and lessons learned while striving to move quickly without compromising the quality of my product or service. From understanding the nuances of selling to setting clear expectations, I hope my insights can help fellow entrepreneurs navigate the exciting world of startups.

The Pitfalls of Overselling Without Understanding

In the early stages of my startup, I found myself leaning too much on over-promising and under-delivering. I would sell features without a clear understanding of the effort and time required to build them. This approach led to missed deadlines and frustrated customers.

Why you should read the fine print

Wed, 17 May 2023 00:00:00 +0000

I was driving a truck in Iraq when the first IED exploded. I remember seeing the vehicle in front of me burst into flames and feeling the heat come through the steering wheel. My world went quiet, and everything felt distant like I was seeing the world through a fishbowl.

The next thing I knew, someone was screaming at me to drive. I snapped out of my daze and hit the gas pedal. We drove as fast as we could to the nearest forward operating base.

Points What Are They Good For

Tue, 09 May 2023 00:00:00 +0000

Should Story Points Be Tied to Time

I often hear people say that story points shouldn’t be tied to time. Instead, they should be based on complexity. This can be for a variety of reasons. For instance, three reasons are cited in this article:

Some tasks are difficult to estimate precisely.
If one developer estimates a project but another completes the task, the estimate becomes invalid. The time needed to complete a task will vary based on a developer’s level of experience.
People generally underestimate obstacles they might face and consider only the best-case scenario.

Each of these reasons presents a concrete problem that should be solved. For example, some tasks are difficult to estimate, but that doesn’t mean you should avoid estimating them. Similarly, different developers may complete tasks at different rates, but that means you should work to figure out how long it will take your team, not change estimates from time to complexity-based.

The Importance of Commander's Intent in Distributed Teams

Tue, 02 May 2023 00:00:00 +0000

Commander’s intent

In today’s world, distributed teams are becoming more and more common. With remote work becoming the norm, the ability for a team to work effectively together relies on everyone understanding the goal and working towards it as hard as possible. In this context, commander’s intent can be a powerful tool for teams to take advantage of opportunities and achieve their goals. In this post, we’ll explore the importance of commander’s intent in distributed teams, and how it can help smaller companies and startups to succeed.

Navigating Time Zone Differences in Remote Teams

Tue, 25 Apr 2023 00:00:00 +0000

In today’s globalized world, remote teams are becoming increasingly common. However, with team members located in different time zones, scheduling meetings and collaborations can become more difficult. In this blog post, we’ll explore some tips and strategies to help remote teams navigate time zone differences and work more effectively together, as well as some common pitfalls to avoid.

What doesn’t work:

No meetings at all: While it may seem like avoiding meetings altogether would solve the time zone issue, it can actually limit communication and collaboration within the team. Lack of regular meetings can lead to team members feeling disconnected from each other and the project.
Leaving availability up to individuals: While it may be tempting to let team members decide their own schedules, this approach can lead to confusion and miscommunication. It requires a lot of discipline and empathy from every team member to ensure that their work hours align with other team members’ schedules.

What does work:

Establish clear expectations: It’s important to establish clear expectations around availability and work schedules. Let team members know what is expected of them in terms of availability for meetings and collaboration, and make sure everyone is on the same page.

Overcoming Lack of Team Cohesion in Remote Teams

Tue, 18 Apr 2023 00:00:00 +0000

Introduction

As remote work has become increasingly popular, businesses face new challenges when it comes to fostering team cohesion. Without face-to-face interactions, building camaraderie and trust can be difficult. However, there are several strategies that can help remote teams overcome these obstacles and create an inclusive and effective work environment.

Encourage Teamwork through Remote Games and Relax Time

One successful strategy for building team cohesion in remote teams is incorporating remote games and relaxation time during work hours. These activities allow team members to interact in a more casual setting and can help break down barriers that may exist in a purely business-focused environment. By allocating time for these activities during work hours, employees are more likely to participate and engage with their colleagues.

Communication in Remote Start-Ups

Tue, 11 Apr 2023 00:00:00 +0000

Communication Challenges in a Remote Startup: Tips for Overcoming Them

Remote work has become increasingly popular in recent years, but it comes with its own unique set of challenges One of the biggest hurdles that remote startups face is communication In this post, we’ll explore some of the common communication challenges in a remote startup and provide tips for overcoming them.

1. Work on Communication Skills

Communication is always more difficult in a remote environment However, there are things you can do to combat this While many people may suggest adding more meetings, this can actually kill productivity Instead, focus on making sure your team knows and learns strong communication skills This means respecting other people’s opinions, avoiding arguments, and taking on disagreements in a tactful manner This doesn’t mean you should hide disagreements, but rather that you should approach them constructively.

How to Be an Empathetic Leader: Strategies for Effective Leadership

Tue, 04 Apr 2023 00:00:00 +0000

Empathy is a critical skill for any leader who wants to build a successful and sustainable organization. It enables leaders to connect with their employees on a personal level, understand their needs and concerns, and create a positive work environment that fosters engagement and productivity. In this article, we’ll explore some practical strategies for becoming a more empathetic leader. In the Marine Corps I was always taught to know your Marines. I believe that is because empathy can only come through understanding.

A Practical Guide to Productive Weekly One-on-One Meetings with Employees

Tue, 28 Mar 2023 00:00:00 +0000

As a manager, it’s essential to have regular one-on-one meetings with your direct reports. These meetings allow you to stay connected with your employees, address their concerns, and give them the feedback they need to grow professionally. In this blog post, we’ll share a simple checklist to help you have effective weekly check-ins with your employees.

The Checklist:

How was last week?
Is there anything I need to know about that I don’t know about?
Are you waiting on me for anything?
What can I do to make your life better?
Do you have any feedback for me?
Do you mind if we go over feedback for you?

The Reasoning:

Having a weekly one-on-one with your direct reports may seem time-consuming, but it’s worth it. You get to know what’s going on with your employees, address any feedback you have for them, and show them that you care about their well-being. Besides, the most crucial aspect of any company is the quality of its people, so it’s essential to spend time caring for your employees.

Failure is Inevitable

Tue, 21 Mar 2023 00:00:00 +0000

Failure is Inevitable

Dealing with failure is an inevitable part of life, especially when you’re an entrepreneur. While it can be tempting to try to avoid failure at all costs, the truth is that failure is an essential part of the learning process. By acknowledging our failures and learning from them, we can become better, more successful versions of ourselves.

How to learn from it

In order to learn from failure, there are three things that we must do:

Why You Should Emulate Containers in Python

Thu, 13 Aug 2020 00:00:00 +0000

The problem

Say that you have a list of items and each item has a price. You would like to highlight the item or items that have the lowest price. If all of the items are the same price you wouldn’t like to highlight any of them. We might have something like the following

import sys


class Item:
  def __init__(self, name, price):
    self.name = name
    self.price = price


items = [Item("1", 1), Item("2", 2), ...]

lowest_price = sys.float_info.max
all_equal = True
last_price = items[0]

for item in items:
  if item.price != last_price:
    all_equal = False
  if item.price < lowest_price
    lowest_price = item.price
  item.last_price = item.price

printable_string = ""
if all_equal:
  for item in items:
    printable_string += item.name + str(item.price) + "\n"
else:
  for item in items:
    if item.price == lowest_price:
      printable_string += "**" + item.name + str(item.price()) + "**\n"
    else:
      printable_string += item.name + str(item.price()) + "\n"

print(printable_string.rstrip("\n"))

This is fine as long as our list is short. Imagine though that our list was incredibly long. You might realize that you have to traverse our items list twice. The first time when we are finding the smallest price and testing if all prices are the same. The second time when we want to print out the items. Given a long enough list this would be less than ideal.

Pomodoro Method Follow Up

Mon, 27 Apr 2020 07:00:54 -0400

Pomodoro Technique

I’ve blogged about it before. Recently I dusted off my old method and tried to implement it. I found that there were some rather strange problems with my old method and MacOS. So I wanted to help some people.

The scripts

We have a few scripts. We have a delayed_mac script. This script just takes a command and a time in mins. It executes the command that many mins later. Next we have a take_a_break script. It sets a timer a timer for 5 or 15 mins later depending on your choice. It will run the pomondoro script after time is up. Next we have a pomodoro script. It asks you what your task is and then sets sets up to run the break script 25 mins later. All of this is written to a file which is gets rolled up with a timestamp. The scripts use atrun to schedule the tasks.

Applications Integrating On The Database

Wed, 25 Mar 2020 09:03:54 -0400

The problem

You shouldn’t do it. You’ve read it before. Don’t integrate applications on the database. The advice is relatively straightforward, but it can often be difficult to understand. My first piece of advice is that when you have a new process it should have it’s own database. While the overhead is often real, it is minimal compared to the pain caused when you want to pull the two processes apart later. However, I find that people often fight against having two databases from the start. They see the immediate pain, and either don’t know (or can’t see) the pain of the future. If they know and then discount the immediate pain, they may be overly discounting future pain. There is a name for this sort of bias, it is called hyperbolic discounting. Regardless, sometimes you decide that you are going to have a single database for multiple processes. Maybe it is because recreating many data models isn’t your idea of fun. Perhaps it is because figuring out how to broker the communication between two apps is no fun. So, you copy the models, or you pull them into a shared location. You allow the database to decide what consistency looks like. This runs smoothly for months (or even years). Then one day you realize you can’t change one application without changing the other. You realize they are tightly coupled, practically speaking, even if they aren’t conceptually speaking.

Repo Scripts And Autoupdates

Wed, 26 Feb 2020 09:03:54 -0400

The problem

You really want to make sure that unit tests are run every time someone commits.

The solution

Three simple scripts. The first should be run by all engineers that join the team. It should do most of the installs for environment dependencies. The second should be a pre-commit script. This script should run your tests and anything else that you want to have happen. The third script should be an update script. It should be a simple script that gets run by your second script. It should automatically update your pre-commit script.

Bugs In Software

Tue, 14 Jan 2020 09:03:54 -0400

The Architecture of Open Source Applications

If you haven’t seen or read The Architecture of Open Source Applications then you are missing out. Sure, it is a bit long. Also, each section is written by a different writer making it slightly inconsistent. But, there are gems throughout the book that make it worth the read.

One of the gems

Here’s an example of one of the gems from the Berkeley DB section.

The Importance Of History

Tue, 10 Dec 2019 09:03:54 -0400

History, what is it good for?

When I interview someone I often ask, “Where did object oriented programming (OOP) come from?” There generally isn’t a right or wrong answer to this in the interview. You can go look up whether a particular answer is consistent with what’s on the internet. However you could give several answers that would all be right. You might say, “it was pioneered in Sketchpad.” Or you might say, “it came out of the atom in LISP.” Both are consistent with history. Each lens can bring a distinct understanding of OOP.

The Telegram Problem

Fri, 15 Nov 2019 09:03:54 -0400

The problem

Write a program that takes a number w, then accepts lines of text and outputs lines of text, where the output lines have as many words as possible but are never longer than w characters. Words may not be split, but you may assume that no single word is too long for a line. Source

Solution

This is a straightforward problem when it comes down to it, but it takes some thinking to get there. We need to work through the different edge cases to figure out exactly how to make this work. I would like to create a solution that deals with channels allowing users to send delete characters and such. I think it would be an interesting problem in itself. That being said, my solution starts out by initializing the output and current output so that we don’t have special cases in our for-loop. It also sanitizes and formats the information that we will be walking over. Next it loops through and checks to see if the line will grow to long. If it won’t, we add to the current line output; if it will, we save the current line output to the total output and then initialize the next line output. Finally, on our way out, we flush the last partial line.

Using Checklist In Software Development

Mon, 09 Sep 2019 09:03:54 -0400

The dream

For some time I have been wanting to incorporate checklist into the development project. My initial inspiration came from The Checklist Manifesto. The book which was initially published in 2009 sent me frantically searching for checklists in software development. At the time I couldn’t find any. Today I use the treasure trove of checklists from Code Complete Two by Steve McConnell. This blog post will describe the use of checklists at my company. Today I will set out to do a few things:

Euler Problem 026

Mon, 19 Aug 2019 09:03:54 -0400

The problem

A unit fraction contains 1 in the numerator. The decimal representation of the unit fractions with denominators 2 to 10 are given:

1/2	= 	0.5
1/3	= 	0.(3)
1/4	= 	0.25
1/5	= 	0.2
1/6	= 	0.1(6)
1/7	= 	0.(142857)
1/8	= 	0.125
1/9	= 	0.(1)
1/10	= 	0.1

Where 0.1(6) means 0.166666…, and has a 1-digit recurring cycle. It can be seen that 1/7 has a 6-digit recurring cycle.

Euler Problem 023

Wed, 31 Jul 2019 09:03:54 -0400

The problem

A perfect number is a number for which the sum of its proper divisors is exactly equal to the number. For example, the sum of the proper divisors of 28 would be 1 + 2 + 4 + 7 + 14 = 28, which means that 28 is a perfect number.

A number n is called deficient if the sum of its proper divisors is less than n and it is called abundant if this sum exceeds n.

Graphing Change Vs Cyclomatic Complexity

Mon, 10 Jun 2019 09:03:54 -0400

The problem

You want to know where you should be refactoring, and you are not sure where to start. Or, you would like to better understand why you have more bugs in one part of the code than another.

One approach

One thing that I like to look at when this happens is cyclomatic complexity. That often isn’t enough to get the full picture of what is happening with code. Another place I like to look is how often a file is changing.

Sudoku Using Go Lang

Wed, 01 May 2019 09:03:54 -0400

Algorithms

A friend of mine recently started looking for work and we were talking about the interview process. She brought up the fact that often coding every day as a professional looks nothing like the toy problems in interviews. This got me thinking about a surprise question that I had during an interview. I was asked to create a Sudoku solver. At the time I was pretty vexed. I’ve never worked as a game programmer. The position I was applying for was not a game programming position. It was a standard full stack web development position. Now I have a lot of thoughts on what interviews should look like and why. One of them is that the interview should look at the relevant skills that are going to be used on a daily basis. That is if you are going to be doing web development then the interview should be about well… web development. I wish I could say this is a post about hiring and interviews, but it isn’t. Someday I’ll come back and I’ll write that post and probably gripe like an old man about hiring practices. How those hiring practices can affect the diversity and capabilities of a team and all that jazz. This post in a weird twist is actually about how I ended up finally writing that Sudoku solver.

Euler Problem 010

Fri, 19 Apr 2019 09:03:54 -0400

The problem

The four adjacent digits in the 1000-digit number that have the greatest product are 9 × 9 × 8 × 9 = 5832.

73167176531330624919225119674426574742355349194934 96983520312774506326239578318016984801869478851843 85861560789112949495459501737958331952853208805511 12540698747158523863050715693290963295227443043557 66896648950445244523161731856403098711121722383113 62229893423380308135336276614282806444486645238749 30358907296290491560440772390713810515859307960866 70172427121883998797908792274921901699720888093776 65727333001053367881220235421809751254540594752243 52584907711670556013604839586446706324415722155397 53697817977846174064955149290862569321978468622482 83972241375657056057490261407972968652414535100474 82166370484403199890008895243450658541227588666881 16427171479924442928230863465674813919123162824586 17866458359124566529476545682848912883142607690042 24219022671055626321111109370544217506941658960408 07198403850962455444362981230987879927244284909188 84580156166097919133875499200524063689912560717606 05886116467109405077541002256983155200055935729725 71636269561882670428252483600823257530420752963450

Find the thirteen adjacent digits in the 1000-digit number that have the greatest product. What is the value of this product?

Solution

This guy is a straightforward fun warm up for the day. A simple loop to walk over the numbers looking in all the possible directions (there are four). Going down and up are the same, going left and right are the same, forward-up is the same as going backward-down, and going forward-down is the same as going backward-up. Then as we traverse we keep track of the largest value.

Euler Problem 009

Wed, 06 Mar 2019 09:03:54 -0400

The problem

A Pythagorean triplet is a set of three natural numbers, a < b < c, for which, a^2 + b^2 = c^2

For example, 32 + 42 = 9 + 16 = 25 = 52.

There exists exactly one Pythagorean triplet for which a + b + c = 1000. Find the product abc.

Solution

This solution is straight forward. We satisfy the constraint that a < b < c by incrementing up by one in each variable and then we search for the solution. At first glance this might seem like an O(n^3) problem, but it’s constant, at least in the sense that we are only going to 1000 and we have no variable inputs. Mine runs fast enough. So I guess brute force it is today.

Prior Art

Mon, 18 Feb 2019 09:03:54 -0400

The Problem

Sometimes there is the “right way” and other times there is “how it is done in the codebase”. I would argue that a majority of the time the “right way” is the “how it is done in the codebase”. This might seem surprising, but generally I think consistency is incredibly important in a codebase. So while at first glance a practice might not be the accepted best practice, you shouldn’t change the codebase unless you can change everything over to the best practice. Recently an employee that was working on a part of the codebase argued that there were sections that weren’t following best practices. In particular the infrastructure code was centralized in one place rather than spread throughout the code in modules. He changed the newest codebase to test out the theory. Up to this point I was completely on board with his decisions. You see a practice that doesn’t match with best practices, you have a an idea on how to fix it, and you try it out. It was the next steps that I really didn’t agree with. At this point everyone agreed it was better to go ahead and have the infrastructure code live close to the code. But due to time constraints the rest of the code was not moved over to the new method.

Blameless Postmortems

Mon, 14 Jan 2019 09:03:54 -0400

Subject

Why should we have blameless postmortems?

Context

I recently read a blog post about blameless postmortems from Etsy. In it there was a simple question about why software engineers shouldn’t be punished:

Why shouldn’t they be punished or reprimanded? Because an engineer who thinks they’re going to be reprimanded are disincentivized to give the details necessary to get an understanding of the mechanism, pathology, and operation of the failure. This lack of understanding of how the accident occurred all but guarantees that it will repeat. If not with the original engineer, another one in the future.

Election Results 2018

Mon, 10 Dec 2018 09:03:54 -0400

Election 2018

The Tuesday Company had the honor to work on many races over the midterm elections. The team worked incredibly hard and managed to help in over 118 different races. We had a chance to scale our technology on a national level and managed to have no production issues despite having an large magnitude of increased traffic. We also learned some valuable lessons about what it means for a team to grow; both in the number of developers and in the number of users.

Load And Performance Testing With Flask

Tue, 13 Nov 2018 09:03:54 -0400

The problem

At my current gig, we’ve spent some time building out our initial product. Things have been going well, and we have been growing. These days we started to notice that some over our API endpoints weren’t as responsive as before. We’ve also started to increase our number of users significantly. To that end, it was time for us to start measuring our requests and fixing them if necessary.

Hope Conference 2018

Wed, 01 Aug 2018 09:03:54 -0400

Context

This weekend I had the joy of going to the Hope Conference. I’ve been going to this conference for a few years and (as usual) I had a wonderful time. Generally speaking, the conference is filled with people who love to create, take things apart, and are curious.

The Good

Some of the highlights of the conference included a talk on SecureDrop, a talk by Steven Rambam about privacy, and a talk about legislation and privacy by Richard Stallman. If you get a chance and are technically inclined I would suggest you watch some of the videos here. They also have a bunch of older videos from previous conferences.

What Does It Mean To Write Ethical Code

Mon, 09 Jul 2018 09:03:54 -0400

Recently I read a report from the 2018 stack overflow survey, here.

From the survey:

Only tiny fractions of developers say that they would write unethical code or that they have no obligation to consider the ethical implications of code, but beyond that, respondents see a lot of ethical gray.

Given the recent investigation into Facebook. I thought it might be prudent to do a little thinking and writing about what it means to write code ethically.

Developing Your Team

Mon, 04 Jun 2018 09:03:54 -0400

The problem

You want to encourage people on your team to be the best they can be.

Some thoughts

I’m a big reader. So the first thing I did when I came across this problem was to start a search on Amazon. Admittedly I only read a few books. I’m no guru. I don’t even think I’m that experienced. But I do think I’ve found a few strategies that have worked so far. I’ve also found some dead ends, therefore this blog post is as much for myself as for anyone else.

Branch By Abstraction

Mon, 07 May 2018 09:03:54 -0400

The problem

I want to write code that is consistently shared with the rest of the team, but I also want trunk based development.

What is branch by abstraction

Paul Hammant a friend and mentor of mine, has two great articles explaining branch by abstraction here and here. The basic concept is pretty easy. Instead of having long lived branches in your version control system, you simply create an abstraction that allows you to change the behavior with only a few minor changes. As great as this concept is, there is one thing missing. During any explanation, I find it difficult to give decent real world examples of branch by abstraction. Usually there are a lot of diagrams and talk about concepts, but very few solid examples. My team has been struggling with doing this in a coherent way, so here are some examples of what it might look like in the wild.

Euler Problem 008

Mon, 02 Apr 2018 09:03:54 -0400

The problem

The four adjacent digits in the 1000-digit number that have the greatest product are 9 × 9 × 8 × 9 = 5832.

73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450

Find the thirteen adjacent digits in the 1000-digit number that have the greatest product. What is the value of this product?

Solution

This guy is a pretty fun warm up for the day. A simple loop to walk over the numbers looking in all the possible directions (there are four). Going down and up are the same, going left and right are the same, forward-up is the same as going backward-down, and going forward-down is the same as going backward-up. Then as we traverse we simply keep track of the largest value.

Pomodoro On Os X Updated

Thu, 29 Mar 2018 09:03:54 -0400

Pomodoro Expanded

Previously I had created a post where I talked about using the pomodoro technique on mac OSX. Well today I want to show how I have expanded on my original idea. First I created this:

#! /bin/sh
at now + $1 minutes <<< $2

Which is a small script to run a bash command at some time in the future. Then I created this:

#!/bin/bash
x=`/usr/bin/osascript <<EOT
tell application "Finder"
    activate
    set myReply to text returned of (display dialog "Start 25 mins: Please put in task" default button 1 buttons {"OK"} default answer "" with icon 1)
end tell
EOT`
echo 'Text is: '$x
if [[ -z "$x" ]]; then
  echo "Done for the day"
else
  mkdir -p $HOME/work
  touch $HOME/work/daily_pomodoro.txt
  echo `date` $x >> $HOME/work/daily_pomodoro.txt
  delayed_mac 25 five_min
fi

Which is little script that takes a description of what I’m going to be doing for the next 25 mins and then logs that to a file with a time. Finally I created this:

Euler Problem 007

Wed, 28 Mar 2018 09:03:54 -0400

The problem

By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.

What is the 10001 prime number?

Solution

Interestingly my first attempt was the good old Sieve of Eratosthenes. However I kept getting an out of memory error from JavaScript. I was using NPM 3.10.3 and would get a no free memory error after GC. My next attempt included going piece by piece and only keeping in memory as many of the composite numbers as necessary and re walking the primes. To remove the new composite numbers. This worked much better. The final solution runs at a very reasonable speed and has no memory issues.

Pairing Vs Code Review

Tue, 27 Mar 2018 09:03:54 -0400

Note This was written mostly immediately after I joined CoreOS and then updated this last week.

I recently started working at CoreOS and one thing that they do there for every change of code is a code review. I have never had code reviews before. I’ve mostly worked in environments where I have paired directly with people. So I wanted to do a quick review on the differences between the two methods.

Starting A Company

Mon, 26 Mar 2018 09:03:54 -0400

Why I’ve been missing for almost a year

In November 2016 some friends of mine were devastated by the Trump and Clinton presidential election. No one had expected Trump to win, and the day after the election Josh Bouy and Jordan Birnholtz got together for breakfast in order to think about what they could do to impact future elections. At that breakfast Jordan realized that he knew someone who was also passionate about the recent election. They contacted Michael Luciani who had been an organizer in the Hillary Clinton campaign. Michael had some great ideas on how technology could be used to help bridge the gap between campaigns and volunteers, but the team had no idea how they would execute this idea. So they reached out Michael’s good friend Shola Farber. Shola had also worked on the Clinton campaign and she knew how to keep things organized. What the team needed now was a way to actually create the technology. For better or for worse, Shola flew to NYC with Michael in tow and they reached out to me. That’s when our team really began in ernest. I spent the evenings and weekends of the next few months building a prototype of the software. It was interesting, fun, and exciting to be working on something that I really cared about. Building technology that would help people engage in the democratic process invigorated me in a way that my previous jobs hadn’t. I love technology and for me often the best part of a job is trying to work with new technology or to manipulate technology in a novel way. The first couple of months were extremely hard. I worked every weekend and every evening often to the point of exhaustion and until I couldn’t work any more. It wasn’t a healthy or sustainable pace, but it was the what I had to do to get things started. Our first test was a very lo-fi experiment in Chicago for the 4th Ward. It went well and we believed that continuing our proof of concept made sense. At this point we got a few paid interns from UChicago and UofM. We were very fortunate to have these two incredibly talented budding software engineers Steven Schmatz and Abi Hunter. We began to build our first product the Team App and the Team Dashboard. It was rocky and we did it in a truly minimum viable product style. We had only interns, almost no budget, and myself who could work only on nights and weekends. We built only what was absolutely necessary for our first client and started to iterate on their feedback. At the same time the Tuesday Company applied to be a part of the Higher Ground Labs accelerator program. It was at this point that we could see things really starting to take off. It has been nothing but a whirlwind since.

Euler Problem 006

Fri, 23 Mar 2018 09:03:54 -0400

The problem

The sum of the squares of the first ten natural numbers is,

1^2 + 2^2 + … + 10^2 = 385 The square of the sum of the first ten natural numbers is,

(1 + 2 + … + 10)^2 = 552 = 3025 Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025 − 385 = 2640.

Euler Problem 005

Thu, 22 Mar 2018 09:03:54 -0400

The problem

2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.

What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?

Solution

Now this guy is a higher order, functional dream. I first create a function that returns a function to see if a number is divisible by another number. Then I create a function that uses that creator to create a function that checks that a number is divisible by every number in the range 1 to that number inclusive. Finally I have a function that starts out skipping by the largest number in the range looking for the smallest number is divisible by every number in that range. The solution looks something like below. There are still a few optimizations that we could make. First we could simply check that the first number is an integer. This would mean we could start our range from two. Second we could remove all redundant numbers if we wanted. For instance if the number is divisible by 20 then it is all divisible by 2, 5, and 10. So we could remove those numbers. However the solution runs fast enough in my browser so I stopped where I was.

Using Quay With Multiple Dockerfiles

Sat, 08 Apr 2017 09:03:54 -0400

The problem

Let’s say you have the following folder layout:

app1/
app2/
shared-infra-resources/
continuous-integration/
                      app1/
                          app1.Dockerfile
                      app2/
                          app2.Dockerfile

And you would like to build app1.Dockerfile and app2.Dockerfile in your Docker registry.

The Solution

If you are using DockerHub. Then you already can’t. DockerHub doesn’t allow you to specify a context separate from your Dockerfile location. At least they did not as of April 8, 2017. So you can’t specify use the continuous-integration/app2/app2.Dockerfile as the Dockerfile location and the root as the context. However, if you are using Quay then you are off to a good start. Quay has a built in build system that you can use to build your repository. In the UI you can either upload a dockerfile or an archive and it will build it. Via the API you can do something very similar, you can request a build on behalf of an organization or a user by sending a post request to https://quay.io/v1/repository///build/ . If you look at the swagger docs you will see you can pass in an archive url, a context, a dockerfile path, and some docker tags. The archive url is simply a url where you can download your build files. The context is the folder in your buildfile that the docker build will be executed from. The dockerfile path is the location and name of the dockerfile. Finally docker tags are arbitrary tag names that can be used to identify your build, version, or whatever other metadata you might want associated with your docker image. The request might look something like this.

Euler Problem 004

Mon, 27 Mar 2017 09:03:54 -0400

The problem

A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 × 99.

Find the largest palindrome made from the product of two 3-digit numbers.

Solution

Now this guy is your daily warm up kind of easy. I created two functions. The first one simply checks a number to see if it is a palindrome. The second one accepts a number finds the largest multiplication combination that is a palindrome. Now I didn’t have to go all the way to zero, but since we are looking for the largest it should work for any number.

Euler Problem 003

Sat, 18 Mar 2017 09:03:54 -0400

The problem

The prime factors of 13195 are 5, 7, 13 and 29.

What is the largest prime factor of the number 600851475143 ?

Solution

This one took a bit longer than I expected. My fist attempt was pretty naive. The idea was generate all the primes less than the number and then check if the number is divisible by the prime. At the end we simple return the largest prime number that divides the number evenly. This works up until we get to 600851475143. Then we start getting out of memory errors and it takes too long. The first attempt looks like this.

Euler Problem 002

Fri, 17 Mar 2017 09:03:54 -0400

The problem

Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:

1, 2, 3, 5, 8, 13, 21, 34, 55, 89, …

By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.

Solution

This is a pretty straight forward problem. We generate the the Fibonacci number and as we go we can check if it isEven keeping track of the sum. Note we don’t actually have to check if the number is even. An odd integer plus an odd integer is even. So every third term we have an even integer. Which means we could just keep track of the count and add only the even integers, but the solution that is presented here goes fast enough that I didn’t really bother with it.

Euler Problem 001

Mon, 13 Mar 2017 09:03:54 -0400

The problem

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.

Find the sum of all the multiples of 3 or 5 below 1000.

Solution

The first algorithm is super straightforward. We want to simply loop over each number between the start and the end checking if the number is a multiple of 3 or 5 and then adding that to the sum. Now this is going to O(n). It isn’t bad at all.

Pomodoro On Os X

Thu, 03 Nov 2016 09:03:54 -0400

Pomodoro

If you haven’t ever used the pomodoro technique then you are missing out. It is a great way to stay focused on one task at a time. It is also a good way to get yourself moving regularly. There is just one thing I don’t like about it. In order to have a good timer you usually have to have something that bothers your neighbor at work. For a while I was using my phone timer which worked okay, but I’m pretty sure my work mates hated me.

A Review Of Test Driven Development With Go

Mon, 12 Sep 2016 09:03:54 -0400

In a previous blog entry I talk about my recent technical challenge with CoreOS. I enjoyed my interview there so much that I started doing some reading about Go. Here’s a second book that I read that I would like to write a review about. It’s called Test-Driven Development With Go written by Yigal Duppen. You can find it on leanpub and it costs $0-14.99. I was tempted when I came across it to pay for it, but I thought maybe I’ll give it a read before I pay the author (authors have to eat too). I’m glad I made that decision. The content in the book is very good, but the book is far from complete. On the bottom of the Leanpub page it says that it has been updated over two years ago and that it is only 10% finished. This was not particularly evident to me when I was first deciding to buy it. The author stops at Ch. 4 obviously not finished. I think the author was on track to write a book as good as Test Driven Development: By Example by Kent Beck. The first chapters do a great job of explaining how test driven development works, and how to implement it in Go. The example is clear and the step by step process is well done. If the author had finished it I would have actually gone back and paid more for the book then the suggested price. As it stands now I wish I knew Go well enough that I could go and finish it for him because someone should. In summary you should definitely download it if you are looking for a very brief intro to test driven development in Go, but I wouldn’t pay the full suggested amount.

Creating A Web Api With Golang

Sat, 10 Sep 2016 09:03:54 -0400

I had a chance for the first time in a while to write some Go. I was writing a simple web API that allowed a user to login with JWT. This blog post is going to be about some of the challenges I faced along the way. I also want to give some shout outs to other blogs that helped me get it written.

The IDE

First let’s start with the IDE. Golang has a great page with all the IDEs that it uses here. I choose LiteIDE because I remembered using it before and it being full featured as well as simple. I can not stress how refreshing it’s simplicity is. I could run tests, compile, and do most things pretty much with push button out of the box. And to boot it is all open source and cross platform compatible. Considering my experiences recently with trying to find a good IDE for JavaScript with built in debugging and test running capabilities this invigorated me. The one thing that I wished happened better was documentation, code navigation, and code completion. Anyone that has used IntelliJ for Java can attest to how powerful the tooling can be in Java. Golang is a strongly typed language with great documentation. I can only imagine that Google has some incredible tools for dealing with with these problems.

A Review Of An Introduction To Programming In Go

Fri, 02 Sep 2016 09:03:54 -0400

Recently I had a chance to write some Go code for the first time in a few years as part of the interview process at CoreOS. The challenge was actually really fun, but so as not to ruin surprise I won’t be talking about what I did during the challenge. Suffice it to say that I had a great experience, and whether or not I get the job at CoreOS I definitely enjoyed the interview process. That said I had such a good time with Go I decided to go looking for a book about it. I found it kind of difficult to find reviews of any of the books so I decided to read a few, and after I was done I thought why not write about it. So this blog post is going to be a review of An Introduction to Programming in Go by Caleb Doxsey. The book is interesting. Chapters 1-5 are for true beginners. You should only really read them if you have never programmed in your life before. They are the standard how to do you do the basics of programming. Interestingly I don’t think I would suggest this part of the book for beginners. Go requires a bit of a set up and it’s a compiled language. If you are really beginning I would suggest using the Go interactive walk through or JavaScript, that way you can focus on just learning the very first steps of programming. After chapter 5 though things get a bit more interesting. The books covers more Go specific functionality. If you don’t have time or an internet connection this is the perfect way to quickly digest a brief overview of the language features and gently introduce the reader to Go idioms. In particular I like the section on next steps. The author points out that you should read the source code to understand the “masters” in order to get better. He also makes the valid point that most nontrivial software is made by teams so learning to be a team player is also important. So while this book is definitely not for Go experts it is worth the quick read if you are just looking to get a brief overview of Go.

Showcases And Why We Need Them

Sat, 27 Aug 2016 09:03:54 -0400

The problem

So my students are mostly awesome. We have come a long way. When we started most of them had not written any JavaScript. In the last few weeks they have been working on their final projects You can see them here, here, here, and here. One thing that they haven’t had a lot of experience with is how to put a whole project together. So we broke them into team and they are coming up with their own product to show future employers. It has been great except for one thing. They have been having trouble prioritizing and getting out features at a regular pace. In Dan Ariely’s book Predictably Irrational he speaks of setting short term deadlines in order to motivate people. So I came up with a plan to help the class along. I proposed that we have the students do showcases every few days. They are expected to have a feature or two in their production environment for each of the showcases (one happens on Sunday and the other on Thursday).

Leaders In An Array In Clojure Basic Algorithms Part Four

Wed, 17 Aug 2016 09:03:54 -0400

The problem

Given an array of integers, print the leaders in the array. A leader is an element which is larger than all the elements in the array to its right.

Solution

Is was my first attempt at coming up with a solution. Naturally I used recursion and simply walked down the array seeing if every element after it was the same.

The time complexity of this is O( n^2 ) which isn’t great.

Moving From Blogger To Clojure

Tue, 09 Aug 2016 09:03:54 -0400

Recently I had a problem with my old blog where writing new blog posts would be buggy. Things like code formatting wouldn’t be consistent and so I moved to images of code. Which is so silly considering that it is just text. I’ve always had a bit of a problem with blogspot. I disliked the lack of control over how things are displayed and served up content. I knew that I wanted to move to HTTPS and that I was tired of working within the confines of WYSIWYG editors. So I took the plunge and decided to create a new clojure app and bought some hosting on Digital Ocean.

The Importance Of Toy Problems

Sat, 06 Aug 2016 09:03:54 -0400

As a software engineer I find that I rarely get to practice the fundamentals of computer science. I also rarely get a chance to practice the kinds of problems at work. At the school that I’m currently teaching one thing that the students have been doing every day is called ’toy problems’. Toy problems are a pretty straight forward concept. They are problems that should make you think a bit, shouldn’t take too long, and let you exercise your programming muscles.

Binary Search Of Sorted Array In Clojure Basic Algorithms Part Three

Wed, 03 Aug 2016 09:03:54 -0400

The problem

Find an element in a sorted array using binary search

The solution

The solution is pretty straight forward. I added in some printlns to get a sense of how we drill down in the recursion to find the element.

(defn binary-search [v value]
  (loop [low 0 high (dec (count v))
         depth 0]
    (let [half-way (quot (+ high low)  2)]
      (do (println (str "half-way is " half-way))
          (println (str "low is " low))
          (println (str "high is " high))
          (println (str "depth is " depth))
          (if (<= high (inc low))
            (cond (= value (v low)) low
              (= value (v high)) high
              :else nil)
            (let [middle (quot (+ low high) 2)]
              (if (< (v middle) value)
                (recur (inc middle) high (inc depth))
                (recur low middle (inc depth)))))))))

You can call the function like this:

Permutations Of A String In Clojure Basic Algorithms Part Two

Wed, 27 Jul 2016 09:03:54 -0400

The problem

Find all permutations of a string

The solution

My first solution is comes from Java and is a recursive solution.

(defn- perms [pre v]
  (let [n (count v)]
    (if (zero? n)
      nil      
      (loop [i 0]
        (if (< i n)
          (do (perms (conj pre (nth v i))
              (into [] (concat(first (split-at i v))
                              (second (split-at (inc i) v)))))
            (recur (inc i)))
          nil)))))

It has some problems. It is recursive so vulnerable to stack overflow errors, but more than that it is pretty slow and not very idiomatic Clojure. So I went in search of a better more idiomatic implementation of this problem and I found this.

Counting Frequencies Of Elements In An Array In Clojure Basic Algorithms Part One

Wed, 20 Jul 2016 09:03:54 -0400

So I’m not a CS guy. I went to school for math and I became a programmer pretty late. I also never had the obligatory algorithms class. So I’m going to start a series where I explore some algorithms coding problems. The problem

So the coding challenge is given an array with N numbers m such that m < N and m is a natural number count the occurrences of m. Solution

Quitting Finance And Trying To Give Back

Tue, 10 May 2016 09:03:54 -0400

I took a leap this week and quit my job at HedgeServ to work for a non-profit called RBK. I moved (May 2016) to Jordan to help teach Syrian refugees how to write software. It’s a bit of a scary plan. I packed all of my stuff up, put it in storage and to take a short break from American corporate career business. The last time I made a decision like this was when I was 17 and full of craziness and I decided to join the military. I wanted to get out of Texas and wasn’t ready to go to college. Being a bit older now, there is much less worry. I don’t have the butterflies that come with doing something unexpected and possibly life changing (at least not yet). There are some things that keep me up. What are people going to think about my leaving a company so shortly after joining it? HedgeServ has been very nice. I have promised I will contact them when I get back if I need work. It was hard to tell my mentor and friend Paul Hammant that I wanted to leave. But, such a good opportunity to use my skills to help those with the least rarely comes along and I couldn’t pass it up. Maybe this will be the start of a new adventure. Maybe I’ll fall in love with Jordan, or the company, or find meaning in helping people and can do this long term. For the time being the first session is only until August so I plan (at least for now) to return to NYC when I’m done. Hopefully I’ll have some cool blog posts about the what I get to teach while I’m there.

Top Down Vs Bottom Up Api Design In Clojure Part One

Tue, 26 Apr 2016 09:03:54 -0400

Recently in my last post…

Recently I posted about the difference between top down vs bottom up design in Clojure, if you haven’t read it then you should. This post is the second part about the differences in both code quality and experience between tope down and bottom up approaches. You can see the commits here.

First impressions

It took me 14 functions using the outside-in method vs 15 functions with the inside-out method. But the number of functions doesn’t really matter. What’s more interesting maybe is the number of characters. It was 2043 for inside-out and 2122 outside-in (without white space). They were pretty close; there wasn’t much of a difference; and counting characters isn’t all that important (though my usual philosophy is ’less is better’). What about readability? Well my opinion is outside-in is marginally better. The main loop is less convoluted. Perhaps because I don’t do any stupid exit business.

Clojure Sieve Of Eratosthenes

Sun, 24 Apr 2016 09:03:54 -0400

I was recently watching a video on Haskell that was showing how you would write a functional form of the Sieve of Eratosthenes. I personally love this algorithm and was interested in what it looked like in Clojure. So I wrote this:

(defn sieve [number xs]
  (if (= 0 number)
    xs
    (conj (sieve (dec number)
                 (filter #(not= 0 (mod % (first xs))) (rest xs)))
          (first xs))))

This works, but Clojure doesn’t have tail call optimization (TCO) by default which means you can get a stack StackOverflowError. So I decided to rewrite it to use the loop and recur construct to remove the StackOverflowError. It looks like this:

The Count Down Problem

Wed, 20 Apr 2016 09:03:54 -0400

Recently I’ve been watching a wonderful set of videos about Haskell during my lunch break. If you are interested in Haskell and functional programming I would definitely recommend the videos.

I found lecture 11 particularly interesting because of a paper that was written about the content here.

The paper is interesting because it shows how you can write a proof for an implementation of a problem in Haskell, then create transformations that speed up that implementation and prove that those transformations are also correct.

Top Down Vs Bottom Up Api Design In Clojure Part Zero

Wed, 20 Apr 2016 09:03:54 -0400

Intro

I saw a lot of presentations at Clojure/conj 2015. Most of them were really great, but one of them I was particularly interested in seeing didn’t really do it for me. It was called Bottom Up vs Top Down Design in Clojure by Mark Bastian. I thought his presentation was interesting, but it failed to touch on a couple of points that I was interested in. In an effort to learn a bit, I figured I would write post about what I was hoping the talk would actually address.

Unit Testing With Higher Order Functions

Wed, 13 Apr 2016 09:03:54 -0400

Recently I was writing an interesting bit of Python software that had a couple of layers. There were some high level objects that dealt with some domain logic and then some lower level objects that did more of the nitty gritty interactions with the operating system. When I first started thinking about writing the lower level interface, I was a little afraid that writing the unit tests was going to be difficult. Wrapping up Sys.out or other IO operations in Java is a standard practice. In the past I have had some trouble patching Python modules.

Does Unit Testing Make Me Slower

Tue, 12 Apr 2016 09:03:54 -0400

Say What?

Recently I asked a coworker if a new application we were working to get into production had unit tests. His response was interesting. He said, “No, but it’s too early to have unit tests. The code hasn’t really settled and unit tests slow you down.”

My initial reaction in my head was “Whoa that’s silly”. But after some consideration and thinking about how code can be written, I’m beginning to see his point. Not the point that we shouldn’t write unit tests, rather that the way many people write unit tests can make writing code more slow. Unit tests do slow you down some, but the rewards of being able to refactor implementations and know that your code is doing what you think it is doing makes up for any extra time you may sink into them. The sooner you can flush out bugs in the development process, the cheaper it is to fix them.

Writing Distributed Test Reduction

Thu, 07 Apr 2016 09:03:54 -0400

The Problem

I recently joined HedgeServ a fintech company and one of my first tasks at the new job has been dealing with how long it takes tests to run. The company has some great end to end test coverage, but the testing time can be rather long (think hours).

The solution

Paul Hammant, my mentor of sorts wrote a blog post about only running tests that actually need to be run when you change a source code set. So my job was to implement a solution that took a set of source files that were touched and only run required tests. This would mean that developers can run only tests that are affected by their source code changes.

Python Source Code Gems

Mon, 04 Apr 2016 09:03:54 -0400

So fairly regularly I read about and dip into the python source code. For some reason there seems to be a great deal of beautiful and interesting code in both the c and the standard libraries and tests for python. The other day I was doing some reading about generators (I was thinking about how to marry the ideas of functional and object oriented programming) and I came across something that I found fascinating as well beautiful so I decided I should share it here on this silly little blog. It’s a full implementation of a generator built Sieve of Eratosthenes in test_generators.py. If you are writing python and you aren’t using generators regularly then you are probably missing something.

The Expression Problem

Thu, 03 Mar 2016 09:03:54 -0400

What is the expression problem?

The expression problem is the idea that it is easy to add new functions for simple data types without changing the data types, while it is hard to add data types without changing all the functions. At the same time it is easy to add data types with objects (complex data types), while it is hard to add functions without changing all the objects.

Some great descriptions of this include chapter 6 of Uncle Bob’s book Clean Code. He doesn’t actually call it the expression problem, but it is. Or you can see it on [Wikipedia(https://en.wikipedia.org/wiki/Expression_problem). Or my personal favorite because this was the first place I came across it, is in a paper from Martin Odersky.

Protonmail Or Why Security Matters

Wed, 11 Nov 2015 09:03:54 -0400

Recently ProtonMail came under a DDoS attack. I was unfortunately one of the people that was affected by this. A few years back after the [Snowden revelations I made a concerted effort to move away from services that cooperated with the NSA. That included companies like Google and Facebook. At the time ProtonMail popped up and I decided to try it out.

Now I’m no security expert, but a lot of the claims made by ProtonMail do seem a bit crazy. Also I’m a bit skeptical of closed source security solutions (Telegram vs Signal anyone?). In any case I figured it would be better than sticking with Gmail. My reasoning went along these lines. While true I couldn’t be certain that my data was being protected at least I wasn’t supporting Gmail who I knew was giving my data directly to the NSA. Also with ProtonMail I had a chance that my data wasn’t being mined for advertisement or mass surveillance purposes.

Structual Type Systems

Sat, 07 Nov 2015 09:03:54 -0400

I was talking recently to a friend about programming languages and how they affect what kinds of software we write when we got on the subject of Golang. He’s a successful vice president of engineering at a ruby shop and I’m a lowly java software engineer, and yet we both agreed on one thing: what people really want is a flexible type system that allows them to rapidly write software. Him coming from the Ruby world wistfully looked off in the distance wishing he didn’t have to worry about runtime type production errors, while basking in the glory of how rapidly and concisely his team could get out code. Me on the other hand tired of slaving away writing so many extra lines of code, while sleeping comfortably with the knowledge that I was unlikely to break any servers in production through type errors.

Debugging Multi Threaded Applications

Sat, 24 Oct 2015 09:03:54 -0400

Recently I had debug a multithreaded application with some surprising results. Seeing as this can be a particularly tricky task for people that haven’t done it before I thought I would write about some lessons I learned from the experience.

logging Logging LOGGING and MORE LOGGING

Log to understand the problem. This one is hard to set up retroactively, but it is well worth the effort. Strive for logs that are meaningful, and that give you checkpoints. For instance avoid putting logs in tight loops. Unless there is something you really need to see inside of the tight loop, move the log out. If you really need to log within a tight loop think about either making the log level DEBUGGING, or only logging every nth element, or doing some other logic to really only log things that you will be interested in. In multithreaded application logging can give you clues on whether or not a thread is starved or when events are happening out of order. Most of the time logs in tight loops will be unhelpful. While some people argue that you should log everything and then use other tools to sift through them I think you will save everyone a whole lot of headaches if you try and log only what you really need. True hard disk space is cheap, true you can roll your logs often to make it easier to sift through them, but at the end of the day the simpler your logs are to sift through the more likely you are to solve the problem.

Feature Branches To Mainline

Sat, 10 Oct 2015 09:03:54 -0400

Recently at my current company my team has been struggling to move from a feature branch workflow to a mainline workflow. I’m going to define what the feature branches and mainline workflows are. Then I’m going to talk about the costs and benefits of both models. Finally I’m going to talk about why people should use the mainline workflow.

Feature Branch Workflow

So what is the feature branch workflow (at least at IntentMedia). For my current team it consisted of someone picking up a story, then creating a new branch, doing the development work, creating a pull request, seeing if the build is green on TeamCity, getting the application checked by a quality analyst, and finally merging in with master.

Making Pairing Comfortable

Sat, 26 Sep 2015 09:03:54 -0400

There are effectively (to me anyways) an infinite number of blog posts about the benefits and costs of pairing and what pairing is and isn’t. So I’m not going to talk about the good and bad of pairing. I’m going to assume that, like me, you want to pair and you see the benefits and costs. Instead today I’m going to talk about how I started experimenting with pairing at my most recent job. For people who would like a run down of pairing see this, this, or Google it.

Configurator Boxen Or Things To Wrangle Your Environment

Sat, 19 Sep 2015 09:03:54 -0400

The problem

One thing that I keep seeing consistently regardless of whether I’m working as a full time employee or as consultant, and that I’ve literally seen from coast to coast is developers and testers trying to simplify their local environments. Increasingly, companies are using multiple services that allow for more module pieces of software (think micro-services). This is nice because it can often simplify coding complexity and dependency graphs, but the flip side is that deployments can become more complex.

Refactoring Tests For Maintainability

Wed, 28 Jan 2015 09:03:54 -0400

I just began working at Intent Media and I’ve been spending some time getting to know the code base. I spent the other day pairing with another guy on the team to add a new feature. We needed to change one of the data models by adding a new field. So we wrote some tests specifying how we thought the new data field should work. Next we got them passing. After that we ran all the unit tests. Oh man were we in trouble. We had twenty-five test failures. I was a little surprised since we had made a pretty small change in the production code.

Problems With Cucumber And Chef

Wed, 06 Mar 2013 09:03:54 -0400

So I’ve been working on getting some cucumber functional tests to run on a remote server lately and had tons of problems. The setup included using Electric Commander to run a gradle task, which in turn ran cucumber using jruby. It was lots of fun. Let me say.

This post is basically because cucumber put out a misleading “error” which when I searched google I couldn’t get any help. So for anyone else who finds themselves in some similar situation. Even if there is only one of you. I hope it helps. So this is what gradle was actually running.

Clojure Web Scraper

Fri, 01 Mar 2013 09:03:54 -0400

Okay so another thing that I did this week was go to a clojure meet up. I really enjoyed it. There I met some really cool people like Anthony from WalmartLabs. In the end we created a hacker news scraper from scratch in a couple of hours. So here is a brief tutorial on how we did it. (Note I’m not that great with Clojure yet thought I do think it is rather awesome. So most of this is because Anthony is a rock star.)

Vagrant Chef Fun

Wed, 27 Feb 2013 09:03:54 -0400

A couple of days ago I got a chance to see some friends of mine (Matt Urbanski and Jinwoo Baek) give a presentation on chef. It was fantastic. Afterward we had a sort of impromptu demo session on using Vagrant and Chef to get an apache server up and running. So this is going to be a quick tutorial on how to use Vagrant and Chef to get a functioning apache server up and running on a vm.

Frank Cucumber

Sun, 17 Feb 2013 09:03:54 -0400

Starting my blog again. So my blog has hopelessly become out of date. Since the last time I posted I’ve started working for ThoughtWorks, gone to India, moved to San Francisco, and finally been put onto my client. Great so now what. Since things are finally starting to settle and since my thoughts have changed on maintaining a blog I’ve decided it’s time to start blogging again. Not that anyone has read anything yet. My goal is to do it once or twice a week depending on time constraints and travel. So lets get started.