<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Posts on nathan leclaire</title>
    <link>https://nathanleclaire.com/post/</link>
    <description>Recent content in Posts on nathan leclaire</description>
    <generator>Hugo -- gohugo.io</generator>
    <lastBuildDate>Tue, 01 Jul 2025 12:00:00 +0000</lastBuildDate><atom:link href="https://nathanleclaire.com/post/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Prompt Engineering is Alive and Well in 2025 - Five Tips</title>
      <link>https://nathanleclaire.com/blog/2025/07/01/prompt-engineering-is-alive-and-well-in-2025-five-tips/</link>
      <pubDate>Tue, 01 Jul 2025 12:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2025/07/01/prompt-engineering-is-alive-and-well-in-2025-five-tips/</guid>
      <description>Lots of people think Prompt Engineering for LLMs is dying because the models have gotten a lot smarter. It&amp;rsquo;s illuminatory to use a heavily quantized open source model and see how stark the difference is. Prompt engineering remains key with these dumber models, and the old standby &amp;ldquo;think step by step&amp;rdquo; tricks are alive and well. Hell, we even have prompt compilers now, which help coerce less smart models into doing the right things.</description>
    </item>
    
    <item>
      <title>In Defense of Superbabies</title>
      <link>https://nathanleclaire.com/blog/2025/04/14/in-defense-of-superbabies/</link>
      <pubDate>Mon, 14 Apr 2025 01:32:23 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2025/04/14/in-defense-of-superbabies/</guid>
      <description>I’m Nathan LeClaire, open source enthusiast and DevOps philosopher, and this past week, I came across a post that has me transfixed: How To Make Superbabies, which is a deep dive on the mechanics and science by which we could craft new humans.
Its conclusion I find both cliché in terms of being LessWrong-ey (The brave, aligned thing is to have a super baby, because they can solve alignment!) and a bit uncanny:</description>
    </item>
    
    <item>
      <title>Emotional Recall: Strengthening Spaced Repetition with AI </title>
      <link>https://nathanleclaire.com/blog/2025/03/30/emotional-recall-strengthening-spaced-repetition-with-ai/</link>
      <pubDate>Sun, 30 Mar 2025 22:32:12 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2025/03/30/emotional-recall-strengthening-spaced-repetition-with-ai/</guid>
      <description>Welcome, I’m Nathan, an SF-based Go hacker with a mission to create bicycles for the mind. I’m always looking for new ways to leverage our “hardware” (nervous system) and upgrade the programming and metaprogramming in our biocomputing layer. Today I’ll talk about one area I’ve been exploring: finding new and creative ways to emotionally turbocharge recall with AI tools.
Anki, a flashcard software built on top of a simple yet incredibly powerful idea (spaced repetition) has become one of my obsessions.</description>
    </item>
    
    <item>
      <title>Vibing Best Practices with Claude Code</title>
      <link>https://nathanleclaire.com/blog/2025/03/10/vibing-best-practices-with-claude-code/</link>
      <pubDate>Mon, 10 Mar 2025 00:43:27 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2025/03/10/vibing-best-practices-with-claude-code/</guid>
      <description>We’ve been seeing a new meme recently that has been repeated ad nauseum, and I’m already more sick of hearing it than I am of seeing Vance memes, but hey, I’m going to go ahead and throw some more fuel on the memetic dumpster fire. For those of you that landed here from Twitter or whatever, I’m Nathan LeClaire — ex-Docker, ex-Honeycomb hacker, Golang, and open source enthusiast, who, like many these days, is getting sucked into AI enthusiasm.</description>
    </item>
    
    <item>
      <title>Fine Tuning a Mystical Assistant with Llama 3 and Unsloth</title>
      <link>https://nathanleclaire.com/blog/2024/06/24/fine-tuning-a-mystical-assistant-with-llama-3-and-unsloth/</link>
      <pubDate>Mon, 24 Jun 2024 01:48:04 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2024/06/24/fine-tuning-a-mystical-assistant-with-llama-3-and-unsloth/</guid>
      <description>Having done a fair amount of experimentation with Stable Diffusion fine tuning, both Dreambooth and LoRA based, I have been eager to try out LLM fine tuning, and the recent releases of Llama models make that dream more realizable than ever. In particular, Unsloth, with its promise of dramatically reduced memory usage has caught my eye. Since I definitely think smaller fine tuning methods like LoRA will play a huge role in evolving the future of LLMs, as evidenced by LoRA assisted small models demonstrating better than GPT-4 level performance on specific tasks, its ability to integrate with LoRA is definitely a plus.</description>
    </item>
    
    <item>
      <title>Prompt Engineering to Grow Yourself a Nanoservice Garden</title>
      <link>https://nathanleclaire.com/blog/2024/06/23/prompt-engineering-to-grow-yourself-a-nanoservice-garden/</link>
      <pubDate>Sun, 23 Jun 2024 01:16:31 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2024/06/23/prompt-engineering-to-grow-yourself-a-nanoservice-garden/</guid>
      <description>About a year ago, riding high on my first access to gpt-4-32k, I cobbled together a project that embodied a vision I&amp;rsquo;d been dreaming on: what if software engineering evolved into a kind of &amp;ldquo;DJ-ing&amp;rdquo; with natural language instead of clunky code? Could we usher in the next million creators of &amp;ldquo;bicycles for the mind&amp;rdquo;? I imagined a world where everyone could nurture their own garden of software, conjuring up bits and pieces to remix with others&#39; creations.</description>
    </item>
    
    <item>
      <title>The Final Frontiers of AI: Chess, Physics, and the Tenacity of the Human Spirit</title>
      <link>https://nathanleclaire.com/blog/2024/06/15/the-final-frontiers-of-ai-chess-physics-and-the-tenacity-of-the-human-spirit/</link>
      <pubDate>Sat, 15 Jun 2024 18:25:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2024/06/15/the-final-frontiers-of-ai-chess-physics-and-the-tenacity-of-the-human-spirit/</guid>
      <description>Deep in the Blue Lately, I&amp;rsquo;ve been getting back into chess, and of course, that brings up thoughts of the epic Kasparov vs. Deep Blue battle. It&amp;rsquo;s a classic tale of how computers weren&amp;rsquo;t good enough to beat humans, but then, pretty rapidly, humans started to lose. Now, chess is pretty much a computer-generated sport.
But there&amp;rsquo;s still hope for the tenacity of the human spirit. Players like Magnus Carlsen bring a lot of fun and popularity back to the game.</description>
    </item>
    
    <item>
      <title>Perplexity Agents, Claude, and the Future of the Web</title>
      <link>https://nathanleclaire.com/blog/2024/06/14/perplexity-agents-claude-and-the-future-of-the-web/</link>
      <pubDate>Fri, 14 Jun 2024 04:43:17 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2024/06/14/perplexity-agents-claude-and-the-future-of-the-web/</guid>
      <description>So, uh, #agents is getting thrown around a lot these days and it&amp;rsquo;s a confusing landscape out there. But I want to talk about recent experiences with my new obsessions like Perplexity, which in my opinion is one of the first approaches at a breakthrough, agent-native system. I’ve also been playing with this cool tool called WebSim (as in Web Simulator), which feels like another stab at a truly AI-native app (rather than just something which bolts on LLMs or other models to existing tools).</description>
    </item>
    
    <item>
      <title>Creating and Visualizing Embeddings with Ollama and ChatGPT</title>
      <link>https://nathanleclaire.com/blog/2024/03/11/creating-and-visualizing-embeddings-with-ollama-and-chatgpt/</link>
      <pubDate>Mon, 11 Mar 2024 01:56:06 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2024/03/11/creating-and-visualizing-embeddings-with-ollama-and-chatgpt/</guid>
      <description>To effectively utilize Language Models (LLMs) with text, you first need to convert the text into numbers. Despite the complex terminology that might be used, this is essentially what embeddings are. If you&amp;rsquo;re subsequently using text in your prompt (like in the case of RAG), it&amp;rsquo;s beneficial to pre-calculate and store these embeddings in your knowledge base.
It&amp;rsquo;s incredibly easy with a tool like Ollama - just make a curl call:</description>
    </item>
    
    <item>
      <title>Playing Around With Ollama for Local LLM</title>
      <link>https://nathanleclaire.com/blog/2024/03/05/playing-around-with-ollama-for-local-llm/</link>
      <pubDate>Tue, 05 Mar 2024 02:24:48 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2024/03/05/playing-around-with-ollama-for-local-llm/</guid>
      <description>It should come as no surprise to anyone who&amp;rsquo;s involved in the tech industry that Large Language Models (LLMs) are a huge trend. Recently, I&amp;rsquo;ve had the opportunity to work with a new LLM tool called &amp;ldquo;ollama&amp;rdquo;, which was developed by some friends of mine from Docker. The experience so far has been quite impressive, to say the least.
Running One of the standout features of ollama is its automatic “scheduling” functionality, which works efficiently across multiple GPUs and OSX metal alike.</description>
    </item>
    
    <item>
      <title>Do We Need a New Orchestration System for GPUs?</title>
      <link>https://nathanleclaire.com/blog/2023/04/06/do-we-need-a-new-orchestration-system-for-gpus/</link>
      <pubDate>Thu, 06 Apr 2023 00:31:24 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2023/04/06/do-we-need-a-new-orchestration-system-for-gpus/</guid>
      <description>Lately, I&amp;rsquo;ve been working on Tensorscale, which was born out of my frustration with not being able to access my perfectly good GPU while working elsewhere on Stable Diffusion projects. Even if I was just sitting on my couch, the problem remained the same. Gradio public sharing or ngrok were potential solutions that could have allowed me to access the automatic1111 web UI, but they had some issues for my use cases.</description>
    </item>
    
    <item>
      <title>Startup Attempts and Failures, 2021 – 2023</title>
      <link>https://nathanleclaire.com/blog/2023/04/05/startup-attempts-and-failures-2021-2023/</link>
      <pubDate>Wed, 05 Apr 2023 04:23:07 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2023/04/05/startup-attempts-and-failures-2021-2023/</guid>
      <description>In 2021, I quit my job at Honeycomb to set out on my own and try to build a company. At first, I wasn’t sure the exact model I’d follow, and had a (perhaps too lofty) aspiration that maybe I’d have a hybrid model, doing a bit of consulting, a bit of real estate, and a bit of product/SaaS/4-hour-workweek livin’ the dream. And, of course, if I happened to hit on something big, I could go raise venture and pursue that.</description>
    </item>
    
    <item>
      <title>Tokio/Rust dyn std::error::Error cannot be sent between threads safely</title>
      <link>https://nathanleclaire.com/blog/2021/11/06/tokio/rust-dyn-stderrorerror-cannot-be-sent-between-threads-safely/</link>
      <pubDate>Sat, 06 Nov 2021 21:25:29 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2021/11/06/tokio/rust-dyn-stderrorerror-cannot-be-sent-between-threads-safely/</guid>
      <description>And for good measure, we&amp;rsquo;ll also talk about error borrowed value does not live long enough, argument requires that var is borrowed for &#39;static, dropped here while still borrowed&amp;hellip;
Boxes, Syncs, and Sends I just ran into an issue with rust code (tokio) where I was trying quite unsuccessfully to port some previously synchronous code to use tokio and async. My code looked like this, as I was working with a function ticks::iqfeed_ticks which previously was taking in some parameters and returning Result&amp;lt;(), Box&amp;lt;dyn Error&amp;gt;&amp;gt;:</description>
    </item>
    
    <item>
      <title>Improving Observability and AIOps with Smarter Sampling</title>
      <link>https://nathanleclaire.com/blog/2021/08/27/improving-observability-and-aiops-with-smarter-sampling/</link>
      <pubDate>Fri, 27 Aug 2021 22:58:56 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2021/08/27/improving-observability-and-aiops-with-smarter-sampling/</guid>
      <description>In the field of financial machine learning, López de Prado has a paper, The Volume Clock, where he talks about sampling observations for model training based not on the mere ticking of the clock, but rather when information actually arrives to the market. For instance, bars might be generated when enough dollars or shares have changed hands instead of every N units of time.
I submit that a similar operation could be applied in DevOps to make sampling smarter and potentially to obtain better results in machine learning use cases for operational telemetry (&amp;quot;AIOps&amp;quot;, if you will).</description>
    </item>
    
    <item>
      <title>Week of 7/12 Podcast Recap: Alex Ellis and Anamita Guha</title>
      <link>https://nathanleclaire.com/blog/2021/07/20/week-of-7/12-podcast-recap-alex-ellis-and-anamita-guha/</link>
      <pubDate>Tue, 20 Jul 2021 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2021/07/20/week-of-7/12-podcast-recap-alex-ellis-and-anamita-guha/</guid>
      <description>Last week I did two great interviews on Coffee Moguls, the new podcast I&amp;rsquo;ve been producing covering Internet entrepreneurs and icons.
Alex Ellis Alex Ellis, who has built a cache of businesses and income streams around open source software, shares his story and advises us how to think about going independent. Alex describes the dilemma of selling open source, comparing it to a three-legged stool, where one of the legs (the commercial arm of the business) has been sawed down.</description>
    </item>
    
    <item>
      <title>TCP Checks, Results, and Timing Out in Rust</title>
      <link>https://nathanleclaire.com/blog/2021/07/19/tcp-checks-results-and-timing-out-in-rust/</link>
      <pubDate>Mon, 19 Jul 2021 00:06:32 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2021/07/19/tcp-checks-results-and-timing-out-in-rust/</guid>
      <description>For the Ogmi project, one area I&amp;rsquo;ve been working on is ingesting and processing historical financial data from DTN IQFeed. I&amp;rsquo;ve been using this as an opportunity to both learn Rust, and take advantage of its fast performance, as the code I was previously relying on in Python is often extremely slow, in some cases to the point of being practically unusable.
I&amp;rsquo;m bundling most of the production bits in Docker containers, of course, and leaning on Hashicorp Nomad for orchestration, as I found Kubernetes a bit too heavyweight at the moment.</description>
    </item>
    
    <item>
      <title>Visualizing User Acquisition as a Directed Acyclic Graph</title>
      <link>https://nathanleclaire.com/blog/2021/05/11/visualizing-user-acquisition-as-a-directed-acyclic-graph/</link>
      <pubDate>Tue, 11 May 2021 03:49:08 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2021/05/11/visualizing-user-acquisition-as-a-directed-acyclic-graph/</guid>
      <description>What is the silver bullet to convert people who have expressed an interest in your product (such as if they have signed up for a free trial) into customers? How do you expand existing accounts to make more? These are the age-old questions.
No one has the answers 1, but if we reflect on it, we probably find that it&amp;rsquo;s likely they&amp;rsquo;re highly dependent on your own particular product and market (or lack thereof) - and we also might find that, terrifyingly, there are no silver bullets.</description>
    </item>
    
    <item>
      <title>I&#39;m winding down my mailing list (and it&#39;s inspiring me to reboot the site)</title>
      <link>https://nathanleclaire.com/blog/2019/03/02/im-winding-down-my-mailing-list-and-its-inspiring-me-to-reboot-the-site/</link>
      <pubDate>Sat, 02 Mar 2019 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2019/03/02/im-winding-down-my-mailing-list-and-its-inspiring-me-to-reboot-the-site/</guid>
      <description>Unfortunately, despite the best of intentions when I first started out and 1000+ subscribers to my mailing list over the years, my blog has been somewhat stagnant in the past few years. I guess the high demands of startup life took a toll on my desire to hack and write for fun, among the million other things competing for my attention and fucks-to-give in adult life. I do intend to fix that by writing more soon, but in the interim I had an unfortunate surprise - Mailchimp has totally deleted my mailing list due to inactivity.</description>
    </item>
    
    <item>
      <title>cURL with HTTP2 Support - A Minimal Alpine-based Docker Image</title>
      <link>https://nathanleclaire.com/blog/2016/08/11/curl-with-http2-support-a-minimal-alpine-based-docker-image/</link>
      <pubDate>Thu, 11 Aug 2016 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2016/08/11/curl-with-http2-support-a-minimal-alpine-based-docker-image/</guid>
      <description>cURL the Night Away One of my favorite open source projects is cURL. Though frequently taken for granted I really feel that it deserves a lot of appreciation and respect. Without curl available in our toolbelt those of use who do heavy interaction with the network (quite a few of us) would really be in a pickle. curl is fast, minimal, and like most good tools, tends to stay out of your way and &amp;ldquo;just work&amp;rdquo;.</description>
    </item>
    
    <item>
      <title>On the Matter of Beautiful git Diffs</title>
      <link>https://nathanleclaire.com/blog/2016/06/28/on-the-matter-of-beautiful-git-diffs/</link>
      <pubDate>Tue, 28 Jun 2016 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2016/06/28/on-the-matter-of-beautiful-git-diffs/</guid>
      <description>git is really one of my favorite tools these days. I love so much about it &amp;ndash; the DAG, the way it makes my life easier by protecting changes, and even the CLI workflow (once you adjust to its initially bizarre behaviors, it&amp;rsquo;s great &amp;ndash; how many tools do you use that are that fast these days?). I feel like it inspires a lot of creative thinking in engineers due to its well-designed core mechanic and rock-solid reliability.</description>
    </item>
    
    <item>
      <title>YAML, HCL, TOML, and Other Fantastic Beasts</title>
      <link>https://nathanleclaire.com/blog/2016/06/13/yaml-hcl-toml-and-other-fantastic-beasts/</link>
      <pubDate>Mon, 13 Jun 2016 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2016/06/13/yaml-hcl-toml-and-other-fantastic-beasts/</guid>
      <description>A Tale Of Three Configs Once upon a time, there was a programmer. She put together a very fun program to post cat pictures to the Internet. Day in and day out her script would run reposting pictures from one social media site to another, and to another in turn. As she continued developing the pawgram program, she eventually found herself wanting to add additional (optional) functionality. For instance, in order to pass the script to someone else to use she would have to stop hard-coding in her passwords and secret tokens for various sites.</description>
    </item>
    
    <item>
      <title>Using Golang 1.6 Templates</title>
      <link>https://nathanleclaire.com/blog/2016/02/23/using-golang-1.6-templates/</link>
      <pubDate>Tue, 23 Feb 2016 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2016/02/23/using-golang-1.6-templates/</guid>
      <description>Very recently Golang 1.6 was announced. There is a tweak to the templating engine that I&amp;rsquo;m pretty happy about and I think you should be too. Here&amp;rsquo;s why.
whitespace Our old friend whitespace rears its ugly head when we go to work with Golang templates. &amp;ldquo;Back in the day&amp;rdquo; when I was developing an application for the web we would use the Smarty templating Engine to spit out HTML. It was glorious &amp;ndash; because of the way that browser rendering works, you didn&amp;rsquo;t need to concern yourself with extraneous whitespace, and so you could layout your rendering of back-end data with quite a bit of flourish, like this:</description>
    </item>
    
    <item>
      <title>Seamless Docker Multihost Overlay Networking on DigitalOcean With Machine, Swarm, and Compose ft. RethinkDB</title>
      <link>https://nathanleclaire.com/blog/2015/11/17/seamless-docker-multihost-overlay-networking-on-digitalocean-with-machine-swarm-and-compose-ft.-rethinkdb/</link>
      <pubDate>Tue, 17 Nov 2015 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2015/11/17/seamless-docker-multihost-overlay-networking-on-digitalocean-with-machine-swarm-and-compose-ft.-rethinkdb/</guid>
      <description>There have been a lot of good articles popping up lately on the new Docker networking features and how to use them with existing Docker tools. So far, most guides will get you through setting up VirtualBox, which is great for getting started, but nothing beats the feeling of getting your hands on an enormous supply of seamlessly networked computing power. So, this article uses Docker Machine, Swarm, and Compose to take it to the cloud and put that power in your hands.</description>
    </item>
    
    <item>
      <title>Using curl and the UNIX socket to talk to the Docker API</title>
      <link>https://nathanleclaire.com/blog/2015/11/12/using-curl-and-the-unix-socket-to-talk-to-the-docker-api/</link>
      <pubDate>Thu, 12 Nov 2015 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2015/11/12/using-curl-and-the-unix-socket-to-talk-to-the-docker-api/</guid>
      <description>Though it is usually hidden behind the docker client binary or other tools, direct communication with the docker API (REST-ish) is sometimes needed in order to debug, understand proper usage, or simply to learn more about the internals of how Docker works. By default the Docker daemon listens on a UNIX socket located at /var/run/docker.sock for incoming HTTP requests, but also can be exposed on a TCP port. In most cases, however, the TCP port exposing the Docker API is secured with TLS (otherwise anyone with access to the API could quite trivially root the box where Docker is running) and accessing TLS-secured endpoints using curl can be a real pain.</description>
    </item>
    
    <item>
      <title>Using Ansible with Docker Machine to Bootstrap Host Nodes</title>
      <link>https://nathanleclaire.com/blog/2015/11/10/using-ansible-with-docker-machine-to-bootstrap-host-nodes/</link>
      <pubDate>Tue, 10 Nov 2015 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2015/11/10/using-ansible-with-docker-machine-to-bootstrap-host-nodes/</guid>
      <description>I&amp;rsquo;m a maintainer and big fan of Docker Machine for quickly generating and using Docker hosts in the cloud and elsewhere. Creating and accessing machines, however, is only the beginning of the battle, as most drivers will leave you with a machine which is a relatively blank slate, and you may want to customize the machines to your liking with a provisioning process of your own in addition to Docker Machine&amp;rsquo;s relatively thin provisioning.</description>
    </item>
    
    <item>
      <title>Interfaces and Composition for Effective Unit Testing in Golang</title>
      <link>https://nathanleclaire.com/blog/2015/10/10/interfaces-and-composition-for-effective-unit-testing-in-golang/</link>
      <pubDate>Sat, 10 Oct 2015 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2015/10/10/interfaces-and-composition-for-effective-unit-testing-in-golang/</guid>
      <description>Go programs, when properly implemented, are fairly simple to test programatically. Go unit tests offer:
 Increased enforcement of behavior expectations beyond the compiler (providing critical assurance around rapidly changing code paths) Fast execution speed (many popular modules&#39; tests can execute completely in seconds) Easy integration into CI pipelines (go test is built right in) Programmatic race condition detection through the -race flag  Consequently, they are by far one of the best ways to ensure code quality and prevent regressions.</description>
    </item>
    
    <item>
      <title>Docker Machine 0.3.0 Sneak Preview: Transmogrify Existing Servers To Be Docker-ready and much, much, more</title>
      <link>https://nathanleclaire.com/blog/2015/06/02/docker-machine-0.3.0-sneak-preview-transmogrify-existing-servers-to-be-docker-ready-and-much-much-more/</link>
      <pubDate>Tue, 02 Jun 2015 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2015/06/02/docker-machine-0.3.0-sneak-preview-transmogrify-existing-servers-to-be-docker-ready-and-much-much-more/</guid>
      <description>SPECIAL SNEAK PREVIEW OF DOCKER MACHINE 0.3.0 Welcome to the Machine. It&amp;rsquo;s release season and the incorrigible Evan Hazlett and I, along with many others whose work I am infinitely appreciative for and could not possibly do without, are firing on all cylinders to try and get the best possible Docker Machine that we can out the door for the 0.3.0 release. There are so many new features and so much goodness in this release that I couldn&amp;rsquo;t possibly do them all justice in a single blog post (although I may well try for the release post), but since I am bursting at the seams with enthusiasm for it I can&amp;rsquo;t help but possibly &amp;ldquo;spill the beans&amp;rdquo; on one of the things we are getting ready to drop and give you a little sneak preview.</description>
    </item>
    
    <item>
      <title>Automating Docker Logging: ElasticSearch, Logstash, Kibana, and Logspout</title>
      <link>https://nathanleclaire.com/blog/2015/04/27/automating-docker-logging-elasticsearch-logstash-kibana-and-logspout/</link>
      <pubDate>Mon, 27 Apr 2015 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2015/04/27/automating-docker-logging-elasticsearch-logstash-kibana-and-logspout/</guid>
      <description>Say that title five times fast! Seriously though, I wasn&amp;rsquo;t sure what else to call this article so that people would actually find it.
This article is a spiritual successor to Evan Hazlett&amp;rsquo;s article on running the ELK stack in Docker and ClusterHQ&amp;rsquo;s article on doing it with Fig/Docker Compose and Flocker. Huge shout out to them for being the giants whose shoulders I stand on. It is also influenced by the recent Borg paper which came out and mentions some of these tools in discussing having a &amp;ldquo;standard stack&amp;rdquo; for doing the sorts of things that we are interested in here and more.</description>
    </item>
    
    <item>
      <title>You&#39;re Not Using This Enough, Part One: Go Interfaces</title>
      <link>https://nathanleclaire.com/blog/2015/03/09/youre-not-using-this-enough-part-one-go-interfaces/</link>
      <pubDate>Mon, 09 Mar 2015 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2015/03/09/youre-not-using-this-enough-part-one-go-interfaces/</guid>
      <description>Go is getting really popular, and it&amp;rsquo;s caused a hilarious amount of confusion as some headstrong developers continue to rage about whether or not it has generics while others quietly or not so quietly get things done with it. I sling a little Go code these days and I wanted to talk to you today about a pattern that can really help your Go code development be more flexible and testable.</description>
    </item>
    
    <item>
      <title>Shelled-out Commands In Golang</title>
      <link>https://nathanleclaire.com/blog/2014/12/29/shelled-out-commands-in-golang/</link>
      <pubDate>Mon, 29 Dec 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/12/29/shelled-out-commands-in-golang/</guid>
      <description>The Nate Shells Out In a perfect world we would have beautifully designed APIs and bindings for everything that we could possibly desire and that includes things which we might want to invoke the shell to do (e.g. run imagemagick commands, invoke git, invoke docker etc.). But especially with burgeoning languages such as Go, it&amp;rsquo;s not as likely that such a module exists (or that it&amp;rsquo;s easy to use, robust, well-tested, etc.</description>
    </item>
    
    <item>
      <title>Migrating to Hugo From Octopress</title>
      <link>https://nathanleclaire.com/blog/2014/12/22/migrating-to-hugo-from-octopress/</link>
      <pubDate>Mon, 22 Dec 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/12/22/migrating-to-hugo-from-octopress/</guid>
      <description>Unfortunately, I haven&amp;rsquo;t been writing as much as I&amp;rsquo;d like to lately. Partially this is because I&amp;rsquo;ve been quite busy with Docker-related things, but it also has a lot to do with aspects of my blogging stack (and approach) that were beginning to show their weaknesses. The way that this blog got started was as an Octopress installation on a Macbook Air. I loved the Octopress default theme&amp;rsquo;s clean design and easy defaults, and I got to hit the ground running super fast.</description>
    </item>
    
    <item>
      <title>The Dockerfile is not the source of truth for your image</title>
      <link>https://nathanleclaire.com/blog/2014/09/29/the-dockerfile-is-not-the-source-of-truth-for-your-image/</link>
      <pubDate>Mon, 29 Sep 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/09/29/the-dockerfile-is-not-the-source-of-truth-for-your-image/</guid>
      <description>As Docker grows in popularity we at Docker Inc. are very pleased and one of the things we are trying to encourage the most is the clearing up of misconceptions in the community. Things move rapidly in the open source world, so we do our best to educate those who are willing to listen. On that note, there&amp;rsquo;s a few thoughts about Dockerfiles that I want to share.
The Dockerfile is a wonderful creation - it allows you to automate the otherwise tedious process of creating Docker images.</description>
    </item>
    
    <item>
      <title>Don&#39;t Be Scared of git rebase</title>
      <link>https://nathanleclaire.com/blog/2014/09/14/dont-be-scared-of-git-rebase/</link>
      <pubDate>Sun, 14 Sep 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/09/14/dont-be-scared-of-git-rebase/</guid>
      <description>Developers like to pretend that we&amp;rsquo;re analytical and make decisions based purely on logic but the truth is that, like most people, we&amp;rsquo;re creatures of emotion and habit first and foremost. We get superstitious sometimes, and in the face of the brain-crushing complexity of modern computing, who wouldn&amp;rsquo;t? One fear I&amp;rsquo;ve noticed is of git (in general) and in particular of git rebase. Indeed, previously I worked on a team where the mere mention of a rebase to the wrong team member could evoke howls of anxiety and protest.</description>
    </item>
    
    <item>
      <title>Bash Scripting and the Legend of the Hidden Bracket</title>
      <link>https://nathanleclaire.com/blog/2014/09/07/bash-scripting-and-the-legend-of-the-hidden-bracket/</link>
      <pubDate>Sun, 07 Sep 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/09/07/bash-scripting-and-the-legend-of-the-hidden-bracket/</guid>
      <description>#!/bin/article It&amp;rsquo;s really amazing sometimes how frequently the shallowness of my UNIX knowledge gets exposed, even though I&amp;rsquo;ve been tinkering around with UNIX for ten-odd years and even own a yellow-paged, dusty old copy of Rob Pike and Brian Kernighan&amp;rsquo;s excellent book &amp;ldquo;THE UNIX PROGRAMMING ENVIRONMENT&amp;rdquo;.
It&amp;rsquo;s a great book, and it outlines a lot of the philosophy of UNIX perfectly, as well as regexp, sed, and other fundamental tools that are essential to being a command line power user.</description>
    </item>
    
    <item>
      <title>Why codegangsta&#39;s cli package is the bomb, and you should use it</title>
      <link>https://nathanleclaire.com/blog/2014/08/31/why-codegangstas-cli-package-is-the-bomb-and-you-should-use-it/</link>
      <pubDate>Sun, 31 Aug 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/08/31/why-codegangstas-cli-package-is-the-bomb-and-you-should-use-it/</guid>
      <description>go go go This week I&amp;rsquo;m writing an opinion piece on why I think that codegangsta&amp;rsquo;s command line interface package for Golang is great, and you should use it. Nice job, contributors!
The reasons are:
 Well designed, and a pleasure to use Lets you get stuff done Flags are how they&amp;rsquo;re meant to be Well documented Friendly community  Well designed, and a pleasure to use This is the library that you dreamed about when you first learned how to use argv and argc in C.</description>
    </item>
    
    <item>
      <title>Handling CTRL-C (interrupt signal) in Golang Programs</title>
      <link>https://nathanleclaire.com/blog/2014/08/24/handling-ctrl-c-interrupt-signal-in-golang-programs/</link>
      <pubDate>Sun, 24 Aug 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/08/24/handling-ctrl-c-interrupt-signal-in-golang-programs/</guid>
      <description>Interruptions Recently I&amp;rsquo;ve been working on a Go program where I will need to do some cleanup work before exiting if the users press CTRL+C (thereby sending an interrupt signal, SIGINT, to the process). I was unsure of how to do this.
As it turns out, signal.Notify is the method by which this is accomplished.
Here is some sample source code:
// Code to set up some services up here...  // After setting everything up!</description>
    </item>
    
    <item>
      <title>Automagical Deploys from Docker Hub</title>
      <link>https://nathanleclaire.com/blog/2014/08/17/automagical-deploys-from-docker-hub/</link>
      <pubDate>Sun, 17 Aug 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/08/17/automagical-deploys-from-docker-hub/</guid>
      <description>I want the speed and other advantages of a static site generator, but with the flexibility of a database-backed CMS.
 I want performance, flexibility, and ease of maintenance. From cars to computers, getting both flexibility and performance all too often requires a carefully weighed set of trade-offs. Generating content for your readers and fans on the web is no exception. On the one hand, techies have recently embraced static site generators such as Jekyll, and for good reason, as these systems provide a lot of advantages (e.</description>
    </item>
    
    <item>
      <title>Don&#39;t Get Bitten by Pointer vs Non-Pointer Method Receivers in Golang</title>
      <link>https://nathanleclaire.com/blog/2014/08/09/dont-get-bitten-by-pointer-vs-non-pointer-method-receivers-in-golang/</link>
      <pubDate>Sat, 09 Aug 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/08/09/dont-get-bitten-by-pointer-vs-non-pointer-method-receivers-in-golang/</guid>
      <description>What? People from all sorts of backgrounds are flocking to the Go Programming Language and even for those who have written C and C++ before (myself included) it may be confusing to grok Go&amp;rsquo;s approach to pointers, and how they interact with the methods you can attach to Go&amp;rsquo;s structs.
In Go, you define a method receiver to specify which struct to attach a certain function to in order to make it invoke-able as a method.</description>
    </item>
    
    <item>
      <title>Write a Function Similar To Underscore.js&#39;s debounce, in Golang</title>
      <link>https://nathanleclaire.com/blog/2014/08/03/write-a-function-similar-to-underscore-dot-jss-debounce-in-golang/</link>
      <pubDate>Sun, 03 Aug 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/08/03/write-a-function-similar-to-underscore-dot-jss-debounce-in-golang/</guid>
      <description>Debounce, eh? As some of you may recall I wrote this post about an interview I bombed with a YCombinator Startup and in it I describe how to implement a debounce (term taken from Underscore.js) type of function from scratch. Recently I found myself having to implement a similar thing in Golang, so I&amp;rsquo;m sharing the results of my implementation here.
What is it? debounce in the Underscore.js documentation:
 Creates and returns a new debounced version of the passed function which will postpone its execution until after wait milliseconds have elapsed since the last time it was invoked.</description>
    </item>
    
    <item>
      <title>Demystifying Golang&#39;s io.Reader and io.Writer Interfaces</title>
      <link>https://nathanleclaire.com/blog/2014/07/19/demystifying-golangs-io-dot-reader-and-io-dot-writer-interfaces/</link>
      <pubDate>Sat, 19 Jul 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/07/19/demystifying-golangs-io-dot-reader-and-io-dot-writer-interfaces/</guid>
      <description>If you&amp;rsquo;re coming to Go from a more flexible, dynamically typed language like Ruby or Python, there may be some confusion as you adjust to the Go way of doing things. In my case, I had some trouble wrapping my head around io.Reader, io.Writer, io.ReadCloser etc. What are they used for, and how can they be included in our Go programs for interesting and helpful results?
Quick interface review To make up for some of the flexibility lost by not having generics, and for other reasons as well, Go provides an abstraction in the form of interfaces.</description>
    </item>
    
    <item>
      <title>10 Docker Tips and Tricks That Will Make You Sing A Whale Song of Joy</title>
      <link>https://nathanleclaire.com/blog/2014/07/12/10-docker-tips-and-tricks-that-will-make-you-sing-a-whale-song-of-joy/</link>
      <pubDate>Sat, 12 Jul 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/07/12/10-docker-tips-and-tricks-that-will-make-you-sing-a-whale-song-of-joy/</guid>
      <description>docker run -it nathanleclaire/article As mentioned in a previous post I just started a shiny new job at Docker Inc. and I&amp;rsquo;ve been accumulating all sorts of good Docker tips and tricks. I think there is probably demand for them in the community, where just the sheer amount of information about Docker to take in is very overwhelming. Once you&amp;rsquo;ve mastered the basics, the creative possibilites are endless, and already my mind has been blown by what some of the folks I work with have come up with.</description>
    </item>
    
    <item>
      <title>RethinkDB is Quietly Changing the Way We Think About Data</title>
      <link>https://nathanleclaire.com/blog/2014/07/01/rethinkdb-is-quietly-changing-the-way-we-think-about-data/</link>
      <pubDate>Tue, 01 Jul 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/07/01/rethinkdb-is-quietly-changing-the-way-we-think-about-data/</guid>
      <description>meet up This past week I attended a meetup at Firebase headquarters in downtown San Francisco. No joke, there is photographic evidence.
It was a very intruiging event since the focus of the conversation was on building real-time apps, and what the future of that is going to look like. Essentially real-time apps are websites or native device applications where the interaction with other users is nearly instantaneous. For instance, if you&amp;rsquo;ve ever edited a Google Doc at the same time as someone else, you will recall that you could see changes that they made in real-time, and vice versa, and so on.</description>
    </item>
    
    <item>
      <title>Original Content Vultures are Evil, and What You Can Do To Protect Yourself</title>
      <link>https://nathanleclaire.com/blog/2014/06/28/original-content-vultures-are-evil-and-what-you-can-do-to-protect-yourself/</link>
      <pubDate>Sat, 28 Jun 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/06/28/original-content-vultures-are-evil-and-what-you-can-do-to-protect-yourself/</guid>
      <description>Here we go So lately I&amp;rsquo;ve had this problem where people will e-mail me, or complain on Twitter, that my website looks pretty mangled on their [OS|browser]. This of course upsets me since I want the experience of using my site to be smooth and simple. I&amp;rsquo;m no designer but I tried to make something that was both usable (loads quite quickly) and not too hard to look at.
So of course I investigate, and I&amp;rsquo;m led to find out that in several of these cases the unsuspecting viewers are stumbling across my site through a &amp;ldquo;gray hat&amp;rdquo; lead farming site.</description>
    </item>
    
    <item>
      <title>Back from the Dead</title>
      <link>https://nathanleclaire.com/blog/2014/06/26/back-from-the-dead/</link>
      <pubDate>Thu, 26 Jun 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/06/26/back-from-the-dead/</guid>
      <description>Hey all, really sorry that I haven&amp;rsquo;t been writing my usual weekly articles. The good news is that the reason I haven&amp;rsquo;t been doing so is that I&amp;rsquo;ve been getting settled in in San Francisco, California! I have started a new job as a Solutions Engineer at Docker Inc..
I&amp;rsquo;m going back to writing weekly articles, don&amp;rsquo;t be surprised to see me writing a fair bit about Docker too :)</description>
    </item>
    
    <item>
      <title>Do We Need a Community for Vagrantfiles?</title>
      <link>https://nathanleclaire.com/blog/2014/05/02/do-we-need-a-community-for-vagrantfiles/</link>
      <pubDate>Fri, 02 May 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/05/02/do-we-need-a-community-for-vagrantfiles/</guid>
      <description>vagrant up For those of you who are unfamiliar, Vagrant is &amp;ldquo;development environments made easy&amp;rdquo;.
 Create and configure lightweight, reproducible, and portable development environments.
 Vagrant is a command line tool that aids in the creation and provisioning of development environments. Why is it important? Let&amp;rsquo;s say that you want to work on a Django application. In order to get started with even basic work on the application you need Python installed, probably pip and virtualenv, the dependencies on Python libraries including Django itself, and a database program (sqlite, MySQL, and PostgreSQL are all popular choices).</description>
    </item>
    
    <item>
      <title>A Surprising Feature of Golang that Colored Me Impressed</title>
      <link>https://nathanleclaire.com/blog/2014/04/27/a-surprising-feature-of-golang-that-colored-me-impressed/</link>
      <pubDate>Sun, 27 Apr 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/04/27/a-surprising-feature-of-golang-that-colored-me-impressed/</guid>
      <description>EDIT: Some commenters were confused about some things in this article, and I don&amp;rsquo;t want people to get an unclear picture, so to clarify:
 Yes, I know that insertion into a hash table creates an arbitrary ordering of elements by definition. For a variety of reasons, e.g. that not every map is a hash map as some posters have pointed out (and some languages have ordered hash maps), I can see how someone might hypothesize (especially with a naïve understanding of Go maps) that iteration order could be the same as insertion order.</description>
    </item>
    
    <item>
      <title>5 AngularJS Antipatterns &amp; Pitfalls</title>
      <link>https://nathanleclaire.com/blog/2014/04/19/5-angularjs-antipatterns-and-pitfalls/</link>
      <pubDate>Sat, 19 Apr 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/04/19/5-angularjs-antipatterns-and-pitfalls/</guid>
      <description>The Angular Jungle AngularJS is a big JavaScript framework and it gives you just enough rope to hang yourself with. I&amp;rsquo;ve written a lot about it in this blog and really hope that I have made a noteworthy impact on improving the general availability of resources. I&amp;rsquo;ve been working on a project using AngularJS at my dayjob lately and noticed some antipatterns and pitfalls that people fall into when they are new to Angular (myself included, so they&amp;rsquo;re based on my own sweat and blood learning the framework) and I&amp;rsquo;ve consolidated some of them here for you to peruse.</description>
    </item>
    
    <item>
      <title>Unit Testing Services in AngularJS for Fun and for Profit</title>
      <link>https://nathanleclaire.com/blog/2014/04/12/unit-testing-services-in-angularjs-for-fun-and-for-profit/</link>
      <pubDate>Sat, 12 Apr 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/04/12/unit-testing-services-in-angularjs-for-fun-and-for-profit/</guid>
      <description>If there was a way to reduce the number of defects in the code you write (or manage), improve the quality and time to market of deliverables, and make things easier to maintain for those who come after you- would you do it?
Right about now, especially given the content of the article, you might be sensing that I&amp;rsquo;m about to jump into the usual testing zealot rant. And you&amp;rsquo;re right.</description>
    </item>
    
    <item>
      <title>Implementing a Concurrent Floodfill with Golang</title>
      <link>https://nathanleclaire.com/blog/2014/04/05/implementing-a-concurrent-floodfill-with-golang/</link>
      <pubDate>Sat, 05 Apr 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/04/05/implementing-a-concurrent-floodfill-with-golang/</guid>
      <description>The setup Lately as part of a coding exercise I found myself implementing a Flood Fill for &amp;ldquo;painting&amp;rdquo; an ASCII canvas. For those of you unfamiliar with what that is, think back to MSPaint - remember that little paint bucket that would fill a region with your color of choice? That paint bucket implements a flood fill algorithm, although I didn&amp;rsquo;t know that&amp;rsquo;s what it was called until I started working on implementing one myself.</description>
    </item>
    
    <item>
      <title>Fixing Cygwin&#39;s SSL issues with git clone c_rehash bug</title>
      <link>https://nathanleclaire.com/blog/2014/03/24/cygwin-git-clone-ssl-issue-c_rehash-openssl-not-found/</link>
      <pubDate>Mon, 24 Mar 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/03/24/cygwin-git-clone-ssl-issue-c_rehash-openssl-not-found/</guid>
      <description>Cygwin&amp;rsquo;s git clone drama Oh, you. When I am working on Windows for the various reasons which compel one to work on Windows I often use Cygwin to provide UNIX-like functionality on the command line (cmd.exe leaves a lot to be desired). Since a vital part of my workflow on any OS is git I happily installed git using the Install.exe workflow that Cygwin provides.
To my surprise (and, I&amp;rsquo;m not going to deny it, slight nerd-rage) when I attempted to git clone a repository from Github I was greeted by an error message like this one:</description>
    </item>
    
    <item>
      <title>What is this Docker thing that everyone is so hyped about?</title>
      <link>https://nathanleclaire.com/blog/2014/03/22/what-is-this-docker-thing-that-everyone-is-so-hyped-about/</link>
      <pubDate>Sat, 22 Mar 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/03/22/what-is-this-docker-thing-that-everyone-is-so-hyped-about/</guid>
      <description>Docker Approximately one year ago I was browsing Hacker News and I came across this video:
I found it profoundly exciting for reasons I could not explain, mostly Solomon&amp;rsquo;s infectious enthusiasm and the enthusiasm that the Hacker News commmunity reacted to it with. When I learned that Docker was being written in Go I was even more intruiged. Especially having played with Go quite a bit, I have a hunch that Go will be a language which dictates the future of the &amp;ldquo;cloud&amp;rdquo; in a lot of ways.</description>
    </item>
    
    <item>
      <title>AngularJS isn&#39;t MVC, it&#39;s SDC</title>
      <link>https://nathanleclaire.com/blog/2014/03/15/angularjs-isnt-mvc-its-sdc/</link>
      <pubDate>Sat, 15 Mar 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/03/15/angularjs-isnt-mvc-its-sdc/</guid>
      <description>Intro I first started learning AngularJS because I was interested in exploring the world of MV* JavaScript frameworks for the client side. There was something intruiging and exciting happening about a year or two ago in that space, as several JS frameworks started to get some steam and critical mass and the mainstream of client-side development (even those boring 5:01 developers couldn&amp;rsquo;t ignore the zeitgeist anymore) seemed to wake up and realize that maybe there was a need for something more than just vanilla jQuery in applications where everything was spiraling way out of control.</description>
    </item>
    
    <item>
      <title>Double Your Talent Acquisition: Five Do&#39;s and Don&#39;ts For Technical Recruiters</title>
      <link>https://nathanleclaire.com/blog/2014/03/08/five-dos-and-donts-for-technical-recruiters/</link>
      <pubDate>Sat, 08 Mar 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/03/08/five-dos-and-donts-for-technical-recruiters/</guid>
      <description>Are you a technical recruiter?
Is it starting to feel like a cold, cold, world out there?
Like it or not, there are a lot of companies competing for technical talent right now and it&amp;rsquo;s hard to differentiate yourself. But you may be making mistakes that could be avoided, and overlooking things that could be used to help improve your conversion rate. How would you like to source more talent, make your clients and recruits happier, and generally recruit like a boss?</description>
    </item>
    
    <item>
      <title>Build a Linked List For Each Layer in a Binary Tree</title>
      <link>https://nathanleclaire.com/blog/2014/03/01/build-a-linked-list-for-each-layer-in-a-binary-tree/</link>
      <pubDate>Sat, 01 Mar 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/03/01/build-a-linked-list-for-each-layer-in-a-binary-tree/</guid>
      <description>I&amp;rsquo;ve been going through problems in Cracking the Coding Interview to keep my chops strong and for giggles and this one took a little bit of wrangling for me to get:
 Given a binary search tree, design an algorithm which creates a linked list of all the nodes at each depth (i e , if you have a tree with depth D, you’ll have D linked lists)
 So a binary tree such as :</description>
    </item>
    
    <item>
      <title>How to Wait for All Goroutines to Finish Executing Before Continuing, Part Two:  Fixing My Oops</title>
      <link>https://nathanleclaire.com/blog/2014/02/21/how-to-wait-for-all-goroutines-to-finish-executing-before-continuing-part-two-fixing-my-ooops/</link>
      <pubDate>Fri, 21 Feb 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/02/21/how-to-wait-for-all-goroutines-to-finish-executing-before-continuing-part-two-fixing-my-ooops/</guid>
      <description>Earlier this week I published an article called How To Wait for All Goroutines to Finish Executing Before Continuing detailing a problem that I&amp;rsquo;d run into while coding with Golang and the solution that I&amp;rsquo;d encountered, which was to use sync.WaitGroup. I was still basking a little in that I-just-finished-a-new-blog-article afterglow when something in the Reddit comments caught my eye!
Turns out that my approach in the previous article causes a race condition.</description>
    </item>
    
    <item>
      <title>How to Wait for All Goroutines to Finish Executing Before Continuing</title>
      <link>https://nathanleclaire.com/blog/2014/02/15/how-to-wait-for-all-goroutines-to-finish-executing-before-continuing/</link>
      <pubDate>Sat, 15 Feb 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/02/15/how-to-wait-for-all-goroutines-to-finish-executing-before-continuing/</guid>
      <description>EDIT: As pointed out by effenn in this Reddit comment, a lot of information in this article is &amp;ldquo;dangerously inaccurate&amp;rdquo;. OOPS! I&amp;rsquo;ve written a followup/correction article here for your viewing pleasure, but I&amp;rsquo;m leaving this article up for &amp;ldquo;historical purposes&amp;rdquo;.
Goroutines and channels are one of Go&amp;rsquo;s nicest language features. They provide a rather headache-free way to use the power of concurrency in your Go programs, and they are baked into the language itself instead of relying on standard or external libraries.</description>
    </item>
    
    <item>
      <title>5 Reasons We Won Startup Weekend</title>
      <link>https://nathanleclaire.com/blog/2014/02/10/5-reasons-we-won-startup-weekend/</link>
      <pubDate>Mon, 10 Feb 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/02/10/5-reasons-we-won-startup-weekend/</guid>
      <description>This previous weekend I participated in Ann Arbor Startup Weekend and had a blast. Our company&amp;rsquo;s name is Fixworthy and we built a photo-based bug tracking app for real life (think Github Issues meets Instagram).
Of course we worked hard on it, lost some sleep etc. but everyone does that. There were some special factors at play in our case that helped us win such as:
 Vagrant and Frequent Deploying Emphasizing &amp;ldquo;Done Is Better Than Perfect&amp;rdquo; Good Design and Aesthetics Finding a Use For Everybody (especially developers) Following the Pain and the Money  Of course, all of these are forces stem from having a smart, talented, and easy-to-work-with team as well.</description>
    </item>
    
    <item>
      <title>The Number One Dev Killer</title>
      <link>https://nathanleclaire.com/blog/2014/02/08/the-number-one-dev-killer/</link>
      <pubDate>Sat, 08 Feb 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/02/08/the-number-one-dev-killer/</guid>
      <description>I frequently find myself fascinated by modern technology. I mean, we went from computers that are the size of buildings to computers of equivalent power that fit in your pocket in ~50 years (I&amp;rsquo;ll leave you to decide if it&amp;rsquo;s sad or not that we use them mostly to look at pictures of cats and argue on the Internet). A pretty impressive feat if you ask me, especially considering that 50 years is just about nothing in geographic terms.</description>
    </item>
    
    <item>
      <title>Banging Your Head Against an AngularJS Issue?  Try This</title>
      <link>https://nathanleclaire.com/blog/2014/01/31/banging-your-head-against-an-angularjs-issue-try-this/</link>
      <pubDate>Fri, 31 Jan 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/01/31/banging-your-head-against-an-angularjs-issue-try-this/</guid>
      <description>As I&amp;rsquo;ve gotten a little into AngularJS I&amp;rsquo;ve been surprised by how often my assumptions about how things will work have turned out to be wrong. When you start to form a basic mental model of how Angular works and you hit your first stumbling block where your model turns out to be incorrect it can be really, really, frustrating. In particular I had one issue that kept cropping up so often I began trying it before running to Google for help if something wasn&amp;rsquo;t working the way I would have expected (all my views should just magically sync up with what&amp;rsquo;s on $scope, right?</description>
    </item>
    
    <item>
      <title>Speed Up Your Workflow By Running PHPUnit Tests Inside of Vim</title>
      <link>https://nathanleclaire.com/blog/2014/01/20/speed-up-your-workflow-by-running-phpunit-tests-inside-of-vim/</link>
      <pubDate>Mon, 20 Jan 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/01/20/speed-up-your-workflow-by-running-phpunit-tests-inside-of-vim/</guid>
      <description>If you&amp;rsquo;re a dev that cares about nice, clean, working code you should probably be writing unit tests. I&amp;rsquo;ve discussed unit testing in AngularJS a bit in one of my previous posts, but what if you are working on the server side with one of the most wildly popular web application languages of all time? That&amp;rsquo;s right folks, I&amp;rsquo;m talking about PHP and whether you love it or hate it if you are working with it there&amp;rsquo;s a damn good chance that you are unit testing it with the venerable PHPUnit (if you&amp;rsquo;re not unit testing at all, you&amp;rsquo;re on the naughty list).</description>
    </item>
    
    <item>
      <title>I Love Hackathons, Long Live Hackathons. I Hate Hackathons, Hackathons Must Die.</title>
      <link>https://nathanleclaire.com/blog/2014/01/18/i-love-hackathons-i-hate-hackathons/</link>
      <pubDate>Sat, 18 Jan 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/01/18/i-love-hackathons-i-hate-hackathons/</guid>
      <description>This weekend I&amp;rsquo;ve been attending MHacks, which is an event in Detroit geared mostly towards college students. It is sponsored by a variety of companies including Quicken Loans, Twilio, Yahoo!, Mashery, Apple and many more. For those of you unfamiliar with the concept, a hackathon is an event where (mostly) young people interested in technology get together to hack (not the naughty kind of hacking) on side projects of their choice and perhaps even compete with each other to win some sweet prizes, or just glory and the respect of their peers.</description>
    </item>
    
    <item>
      <title>Dragging and Dropping Images From One Browser Tab to Another In AngularJS</title>
      <link>https://nathanleclaire.com/blog/2014/01/11/dragging-and-dropping-images-from-one-browser-tab-to-another-in-angularjs/</link>
      <pubDate>Sat, 11 Jan 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/01/11/dragging-and-dropping-images-from-one-browser-tab-to-another-in-angularjs/</guid>
      <description>So, I catch a lot of flak for not having a Facebook. I used to have one about six years ago, when &amp;lt;trolling&amp;gt; it was actually cool, our parents weren&amp;rsquo;t on it, and we had no idea the NSA was watching our every little status update &amp;lt;/trolling&amp;gt;. Then, for a variety of reasons, I deleted it. Since then, people have complained endlessly about a dearth of Nate on social media, so I have started on a new website/project called The Natewerk, which is going to be the #1 social network for people who know me.</description>
    </item>
    
    <item>
      <title>4 Smooth AngularJS Application Tips</title>
      <link>https://nathanleclaire.com/blog/2014/01/04/5-smooth-angularjs-application-tips/</link>
      <pubDate>Sat, 04 Jan 2014 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2014/01/04/5-smooth-angularjs-application-tips/</guid>
      <description>Anyone who follows my blog even a little closely can probably see that I &amp;lt;3 AngularJS:
 How to Unit Test Controllers In AngularJS Without Setting Your Hair On Fire Don’t Fear Directives In AngularJS Fear and Loathing With Golang and AngularJS  As I&amp;rsquo;ve learned more about the framework, I&amp;rsquo;ve come to appreciate many of the design decisions in spite of their initial (beastly) learning curve. For example, directives provide an absurd amount of flexibility and expressiveness in writing declarative HTML that is unmatched by jQuery-style imperative DOM twiddling.</description>
    </item>
    
    <item>
      <title>The Good, The Bad, and The Ugly of Sails.js, Realtime JavaScript MVC Framework</title>
      <link>https://nathanleclaire.com/blog/2013/12/28/the-good-the-bad-and-the-ugly-of-sails-dot-js-realtime-javascript-mvc-framework/</link>
      <pubDate>Sat, 28 Dec 2013 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2013/12/28/the-good-the-bad-and-the-ugly-of-sails-dot-js-realtime-javascript-mvc-framework/</guid>
      <description>Over the Christmas vacation time that I&amp;rsquo;ve been taking I&amp;rsquo;ve been finding myself drawn back to Node.js, mostly for the promise of rapid web application development and not having to switch languages when changing from working on the server-side and the client-side. As part of my interest in developing applications using WebSockets for their real-time capabilities, I looked into Derby and Meteor and eventually I stumbled across Sails.js, the new kid on the block.</description>
    </item>
    
    <item>
      <title>Sending Email From Gmail Using Golang</title>
      <link>https://nathanleclaire.com/blog/2013/12/17/sending-email-from-gmail-using-golang/</link>
      <pubDate>Tue, 17 Dec 2013 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2013/12/17/sending-email-from-gmail-using-golang/</guid>
      <description>As part of the soon-to-be-deployed checkforbrokenlinks app, I found myself faced with the task of creating a contact form that would allow users to send me feedback on the app, so I could improve it and make it better in the future. In order to do so I had to figure out a way to configure my server-side backend, written in Golang, to perform all of the neccessary steps in order to send me an e-mail from the front-end (written in AngularJS).</description>
    </item>
    
    <item>
      <title>How to Unit Test Controllers In AngularJS Without Setting Your Hair On Fire</title>
      <link>https://nathanleclaire.com/blog/2013/12/13/how-to-unit-test-controllers-in-angularjs-without-setting-your-hair-on-fire/</link>
      <pubDate>Fri, 13 Dec 2013 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2013/12/13/how-to-unit-test-controllers-in-angularjs-without-setting-your-hair-on-fire/</guid>
      <description>Developers almost universally agree that unit tests are a VERY GOOD THING when working on a project. They help you feel like your code is airtight, ensure reliability in production, and let you refactor with confidence when there is a need to do so.
AngularJS code touts its high degree of testability, which is a reasonable claim. In much of the documentation end to end tests are provided with the examples.</description>
    </item>
    
    <item>
      <title>Don&#39;t Fear Directives In AngularJS</title>
      <link>https://nathanleclaire.com/blog/2013/12/07/dont-fear-directives-in-angular-js/</link>
      <pubDate>Sat, 07 Dec 2013 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2013/12/07/dont-fear-directives-in-angular-js/</guid>
      <description>Direct what? As I mentioned in last week&amp;rsquo;s article I have been working with AngularJS for personal projects lately. This was largely the result of me, approximately six or seven months ago, feeling like I was missing out on the new hotness by not knowing a client-side MV* framework. I looked around at a lot of options, including:
 Backbone.js (A crowd favorite, with rock-solid online support/documentation/tutorials) Ember.js Knockout.js  Ultimately I fell into learning Angular for a variety of reasons.</description>
    </item>
    
    <item>
      <title>Fear and Loathing With Golang and AngularJS</title>
      <link>https://nathanleclaire.com/blog/2013/11/30/fear-and-loathing-with-golang-and-angular-js/</link>
      <pubDate>Sat, 30 Nov 2013 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2013/11/30/fear-and-loathing-with-golang-and-angular-js/</guid>
      <description>Recently I&amp;rsquo;ve been building an app to check a web page for broken links using Golang and AngularJS (it&amp;rsquo;s for use with this blog, actually, as well as general public consumption). It&amp;rsquo;s pretty close to being done, except for a contact form which will allow people to send an e-mail directly to me (which has involved all manner of fun with Go&amp;rsquo;s smtp library and will most likely be the subject of a future blog post) to make suggestions, send comments, flame me for creating a free tool for them to use, etc.</description>
    </item>
    
    <item>
      <title>How I Automated &#34;Finding Almost Anyone&#39;s Email Address&#34;</title>
      <link>https://nathanleclaire.com/blog/2013/11/23/how-i-automated-finding-almost-anyones-email-address/</link>
      <pubDate>Sat, 23 Nov 2013 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2013/11/23/how-i-automated-finding-almost-anyones-email-address/</guid>
      <description>EDIT: The original article author, Rob Ousbey, has popped up on various social media sites to remind everyone to use this tool/knowledge responsibly. I agree. Please be responsible.
Not too long ago I came across an article on Hacker News called &amp;ldquo;The cold emails that got me meetings at Twitter, LinkedIn and GitHub&amp;rdquo;. It&amp;rsquo;s by a woman named Iris Shoor who is a co-founder of a startup called Takipi. In the article she describes how she used a certain technique originally presented here to obtain access to the emails of decision makers at tech companies and cold email them to glean meetings which resulted in sales of her product.</description>
    </item>
    
    <item>
      <title>The (JavaScript) Question I Bombed In An Interview With a Y Combinator Startup</title>
      <link>https://nathanleclaire.com/blog/2013/11/16/the-javascript-question-i-bombed-in-an-interview-with-a-y-combinator-startup/</link>
      <pubDate>Sat, 16 Nov 2013 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2013/11/16/the-javascript-question-i-bombed-in-an-interview-with-a-y-combinator-startup/</guid>
      <description>About a year and a half ago, I was on the hunt for my first &amp;ldquo;real&amp;rdquo; job. I knew that I wanted to be a &amp;ldquo;web developer&amp;rdquo; (whatever that entails) but I had no idea where to begin. I knew just a smidge of PHP. I was developing websites in Classic ASP at my current internship, but I knew that was an antiquidated technology which was unlikely to help me in the modern job market.</description>
    </item>
    
    <item>
      <title>Want to Work With Databases In Golang?  Let&#39;s Try Some gorp.</title>
      <link>https://nathanleclaire.com/blog/2013/11/04/want-to-work-with-databases-in-golang-lets-try-some-gorp/</link>
      <pubDate>Mon, 04 Nov 2013 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2013/11/04/want-to-work-with-databases-in-golang-lets-try-some-gorp/</guid>
      <description>Google&amp;rsquo;s Go Go is a new programming language released by Google. It has an excellent pedigree (see Rob Pike and Ken Thompson) and it brings a lot of interesting things to the table as a programming tool. Go has been the subject of rave reviews as well as controversy. As Google is a web company it&amp;rsquo;s no surprise that Go seems hard-wired from the start to be used in the context of the modern web and the standard libaries include everything from HTTP servers to a templating system to address these ends.</description>
    </item>
    
    <item>
      <title>5 Cool Unix Hacks For Fun and Productivity</title>
      <link>https://nathanleclaire.com/blog/2013/10/27/5-cool-unix-hacks-for-fun-and-productivity/</link>
      <pubDate>Sun, 27 Oct 2013 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2013/10/27/5-cool-unix-hacks-for-fun-and-productivity/</guid>
      <description>In my workflow I am always looking for ways to be more productive, and to have more fun while developing. There&amp;rsquo;s nothing quite like the feeling of flying through a sequence of commands in bash that you know would take your peers twice as long to execute. Have you ever :
 Raged silently at a coworker for spamming the left arrow key to get to the beginning of their terminal prompt when they could have just pressed CTRL + A ?</description>
    </item>
    
    <item>
      <title>Three Elements That Sum To Zero</title>
      <link>https://nathanleclaire.com/blog/2013/10/22/three-elements-that-sum-to-zero/</link>
      <pubDate>Tue, 22 Oct 2013 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2013/10/22/three-elements-that-sum-to-zero/</guid>
      <description>There&amp;rsquo;s an interview question (for developers) that recently I&amp;rsquo;ve been asking (if they have already proven they can FizzBuzz) which goes a little something like this:
I first heard this question in an interview with a San Francisco-based startup, and it has since become sort of a workhorse interview question around the office. As it turns out, this question has the potential to nerd snipe developers pretty effectively. I know, because I coded up the naive solution first before deciding that it wasn&amp;rsquo;t good enough, and that I wanted to write it a faster way.</description>
    </item>
    
    <item>
      <title>Commit Every Day, Blog Every Week</title>
      <link>https://nathanleclaire.com/blog/2013/10/16/commit-every-day/</link>
      <pubDate>Wed, 16 Oct 2013 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2013/10/16/commit-every-day/</guid>
      <description>It is with the greatest of pride that I am announcing today my newest initiative. I am going to write at least one blog post every week for the next 52 weeks, and I am going to make at least one commit every day- preferably to Github, and most likely on my own personal projects, but bonus points would be given for committing to community projects. This effort is more than a little inspired by Jennifer Dewalt&amp;rsquo;s impressive 180 websites in 180 days project.</description>
    </item>
    
    <item>
      <title>Learn Node.js The Troll Way</title>
      <link>https://nathanleclaire.com/blog/2013/02/06/learn-node-dot-js-the-troll-way/</link>
      <pubDate>Wed, 06 Feb 2013 00:00:00 +0000</pubDate>
      
      <guid>https://nathanleclaire.com/blog/2013/02/06/learn-node-dot-js-the-troll-way/</guid>
      <description>Server Side JavaScript As many of you are probably aware, Node.js is all the rage with the kids these days. It&amp;rsquo;s so popular that users even have the nerve to gall Google developers, insisting that the V8 JavaScript engine is important for things outside of mere Chrome. Node has rapidly been evolving and maturing into the new hotness of the web development community. Its core is driven by the idea of asynchronous input and output, a way to manage the latency inherent in developing applications for the web.</description>
    </item>
    
  </channel>
</rss>
