jonmagic.com

The Feedback Loop I Was Missing

2026-06-04T00:00:00Z

This last weekend I was doing my best to live in the moment and my daughter asked me if we could play Minecraft. We did for an hour or two and then, inspired by a conversation with a friend, I asked if she wanted to build her own Minecraft-like game.

She was excited about the idea so I spent a few minutes with GitHub Copilot and put together an AGENTS.md that had the rough draft of the milestones to build a game like, instructions to red-green-refactor, my self-improvement loop, and an understanding that the agent would be driven by an eight-year-old.

After setting up her computer with an agent and these instructions, things were going quite well but she kept asking me to explain what the agent was doing and every time it required input it would take her a while to turn her feedback into typed text that the agent could act on. This constant struggle to understand the agent and respond resulted in lost attention and flow. So we started iterating.

Speaking with the agent

First we leveraged the Voice mode built into agents like Copilot and Claude. This was a big win, she could press and hold the spacebar and dictate, read what was captured, and press enter to get the agent back to work. For an hour this was great, but she was getting frustrated waiting on me every time she needed the output explained.

Then I had an idea to use the say CLI that ships with macOS and a set of agent instructions to drive that CLI.

say "Hello, I am an agent and I am speaking to you."

So I updated the AGENTS.md for the project to include the instructions below and it worked!

When using tools or doing multi-step work, speak short status updates with the macOS say command. Do not read logs, code, secrets, or long explanations out loud.

That said, what it read was still pretty technical, and this reminded me of something a coworker had mentioned they were using a lot in their prompts recently, ELI5, aka explain it to me like I’m five years old. So I added this to the instructions.

When you speak, speak like you are explaining to a five-year-old. Use simple language and short sentences.

We got back to work and the experience was incredible. The agent would speak to us about what it was doing, what changed, and when it needed input. She could understand the updates without me having to explain them and she could stay in the flow by using voice input to respond to the agent’s requests.

Audio triggers different brain pathways

After working like this for an hour I realized my brain was responding to the audio updates in a different way than it did to text on a screen. The audio updates made it easier for me to re-enter the agent’s state and understand what was happening without having to read through a wall of text.

This is when the seed of an idea started to germinate 💡 Could a more natural feedback loop solve a problem I’d been struggling with for months? I often have multiple agents running but I can only focus on one project at a time. I was constantly hopping between agent windows to check on the status of each agent, which pulled me out of flow. What if these simple spoken updates were queued so I could listen and react to them when I was ready?

The say version proved the shape of the feedback loop, but it was too blunt for the way I actually work. If every agent can speak whenever it wants, the room gets noisy fast. I did not want a bunch of agents interrupting me and speaking over each other. I wanted each agent to leave a short update, and I wanted to decide when I was ready to hear it.

Turning `say` into Relay

That became Tri-State Relay Service, a small macOS app and CLI where agents leave short updates in a local queue instead of speaking over each other.

Each project or context gets a line. A line can stay quiet while I am focused, wait with an update, and become active when I choose to listen.

The goal is audio feedback on demand, not constant interruption.

I’m releasing it for free and the source is on GitHub. I mostly want to get it into people’s hands and see whether this feedback loop helps anyone else.

If you want to try it, here is the user manual and download.

GitHub Copilot Session Search and Resume CLI

2026-04-12T00:00:00Z

Last week I switched to copilot-cli as my full-time coding agent. I’d been splitting my time between it and opencode for months, using Copilot a few times a week, gravitating back to opencode for daily work. But after returning from two weeks of vacation to a fresh laptop, I committed to using only the latest copilot-cli for a full week. By the end of it I sent this to the team internally:

I gotta say, things are finally at the point where I’m not tempted to switch back to opencode. Amazing work everyone. I’m going to start annoying my friends that still use claude code and get them to try switching to copilot again.

One friction point lingered though. Finding my way back to previous sessions.

e-too-many-sessions

I run multiple Copilot sessions a day across different folders and repos. My Brain (personal knowledge base), work projects, side projects, home automation. Open a tab, start a session, do some work, close it, move on. An hour later I’d think “I need to pick that back up” and have no idea which session it was. My workaround was manually copy-pasting session IDs into my weekly note so I could copilot --resume=<uuid> later. It worked, but it felt wrong.

~/.copilot/ 👀

The copilot-cli stores all its state on disk at ~/.copilot/. Each session gets its own directory under session-state/ with an events.jsonl event log and a workspace.yaml metadata file. But the interesting discovery was session-store.db, a SQLite database copilot-cli maintains automatically.

~/.copilot/
├── config.json
├── session-state/           # One directory per session
│   └── <uuid>/
│       ├── events.jsonl     # Every event that happened
│       ├── workspace.yaml   # Session metadata
│       └── checkpoints/     # Snapshot history
├── session-store.db         # ← The good stuff
└── mcp-config.json

I opened session-store.db with sqlite3 and found six tables.

Table	What’s in it
`sessions`	ID, auto-generated summary, repository, branch, timestamps
`turns`	Every user message and assistant response
`checkpoints`	Titled snapshots with overviews and next steps
`session_files`	Every file touched during the session
`session_refs`	Commits, PRs, and issues linked to the session
`search_index`	FTS5 full-text search across all content

That last one caught my eye. It looks like copilot-cli maintains an FTS5 full-text search index across all session content. And the summaries in the sessions table? Already generated automatically, no LLM call needed to get a human-readable title for every session.

copilot-sessions

Once I understood the data, the tool was straightforward. Query the database, pipe through fzf for interactive fuzzy search, resume the chosen session:

# Browse recent sessions
cs

# Search for a session
cs home assistant

# List without fzf
cs -l

The output looks like this:

  TIME     REPO             SESSION
  11m ago  brain            Home Assistant Automation Ideas
  1h ago   brain            Research Copilot CLI Theme
  4h ago   brain            Review And Seed Spotify Playlist
  13h ago  brain            Enable Ghostty SSH Terminal

Pick one, hit Enter, and Copilot resumes right in your terminal. ctrl-y copies the session ID to clipboard if you need it elsewhere.

Search uses fzf’s fuzzy matching against session summaries, all user messages, and repository names. That means it’s typo-tolerant. mincraft finds your Minecraft session, sptoify finds Spotify. It supports substring matching and multi-word queries too. The user messages are appended off-screen so fzf can match against them without cluttering the display.

All the formatting (relative timestamps, repo name truncation, column layout) happens inside a single SQLite query. No bash loops or per-row shell-outs. Startup is about 20ms for hundreds of sessions.

I published it as copilot-sessions.

If you use copilot -p <prompt> for automations (e.g., a cronjob running every few minutes), those sessions will show up in your search results too. I found it helpful to have the automation’s prompt include a step that deletes its own session from session-store.db at the end so it doesn’t clutter things up or become resumable.

…one more thing

The events.jsonl file in each session directory is a streaming log of everything that happened. Every tool call, every file edit, every shell command, all with timestamps:

{"type":"session.start","timestamp":"...","data":{"context":{"repository":"jonmagic/copilot-sessions","branch":"main"}}}
{"type":"tool.execution_start","timestamp":"...","data":{"toolName":"grep","arguments":{...}}}
{"type":"tool.execution_complete","timestamp":"...","data":{"success":true}}
{"type":"session.shutdown","timestamp":"...","data":{"modelMetrics":{"gpt-5.4":{"usage":{"inputTokens":192048}}}}}

There’s a lot you could build on this. Session analytics, cross-session file search, timeline visualizations. For now I’m happy just being able to find my sessions without keeping a manual list.

I work at GitHub, which helped me confirm some of these findings by reviewing internal code. But everything described here is observable by anyone with copilot-cli installed. Just open ~/.copilot/ and start exploring.

Stop Putting Secrets in .env Files

2026-02-27T00:00:00Z

Update (Feb 28, 2026): This post got a lot of discussion on Hacker News and Lobsters. Two things worth addressing.

First, several people pointed out 1Password Environments, a newer feature I hadn’t tried yet. It mounts a .env file backed by a UNIX named pipe (FIFO) so your existing dotenv libraries just work, but no plaintext ever lands on disk. Authorization persists until 1Password locks, which solves the repeated Touch ID prompts you’d get with op run. If you’re already using 1Password this is probably the best option available today.

Second, a fair critique. Injecting secrets as environment variables doesn’t make them invisible. On Linux, any process running as your user can read /proc/self/environ (or /proc/<pid>/environ for other processes you own). On macOS there’s no /proc filesystem, but environment variables are still accessible through other means. Runtime injection is a meaningful improvement over plaintext files sitting on disk, but it’s not a complete security boundary. For higher-stakes environments, look at tools that use short-lived credentials, mounted secrets via tmpfs, or hardware-backed keystores.

A few weeks ago my friend Harrison (@hktouw) and I did our yearly Tesla FSD cruise around the Bay Area — seven hours of letting the car drive while we talk about whatever comes to mind. This was the first year we never had to take over the wheel, which meant even more time for conversation. We covered AI adoption, investing, and then landed on something that’s been bugging me for a while. Why do we still store credentials in plaintext .env files?

I’d been using 1Password to store individual secrets for a while, pulling them one at a time with the CLI. Harrison took it a step further. “Why not store the whole .env file’s worth of secrets as fields in a single 1Password item?” he said. Simple. Obvious in hindsight. And it led me down a rabbit hole of rethinking how I handle secrets in every project.

The result is a pattern I’ve been using for the past month that I want to share. It’s not complicated. It doesn’t require enterprise tooling. It works today with tools you probably already have.

The problem with .env files

We all know .env files are supposed to be gitignored. And they usually are. But beyond the git risk, having credentials stored in plaintext just feels bad. If you leave your laptop unlocked at a coffee shop or someone gets access to your machine, those .env files are sitting right there — high-value targets with zero protection.

Here’s what actually happens with .env files.

They get copied into Slack DMs when onboarding a new teammate
They accumulate across 20+ projects with the same stale API key
A credential gets rotated and you’re hunting through every project directory to find the copies
Someone clones the repo on a new machine and asks you to send them the .env file
They sit on disk as plaintext, readable by any process running as your user
If someone gains access to your machine, they instantly have every credential you’ve ever stored this way

The twelve-factor app told us to put config in the environment. Good advice. But .env files are a leaky implementation of that principle. They’re plaintext files pretending to be environment variables.

Inject at runtime, never store on disk

The pattern is simple. Instead of loading secrets from a file, you use a wrapper script that fetches secrets from a secure store and injects them as environment variables into your process:

# Instead of this:
source .env && node server.js

# Do this:
./with-1password.sh node server.js
# or
./with-keychain.sh node server.js

Your application doesn’t change at all. It still reads process.env.API_KEY or $DATABASE_URL the same way it always did. The difference is where the values come from.

I built a demo repo with two working implementations: one for 1Password CLI and one for macOS Keychain. You can clone it and try both in about five minutes.

1Password CLI

This is the approach Harrison and I were originally talking about, and it’s the one I reach for most. If you already use 1Password, the CLI (op) makes this almost frictionless.

The key insight is that 1Password supports secret references — URIs like op://Development/myapp/api-key that point to a field in your vault. You can put these references in a file that’s safe to commit:

# .env.1password — safe to commit, contains no secrets
API_KEY=op://Development/secure-env-demo/api-key
DATABASE_URL=op://Development/secure-env-demo/database-url
WEBHOOK_SECRET=op://Development/secure-env-demo/webhook-secret

Then the wrapper script is almost trivially simple:

#!/usr/bin/env bash
exec op run --env-file=".env.1password" -- "$@"

That’s it. op run reads the references, fetches each secret from your vault (authenticating via Touch ID or your master password), injects them as environment variables, and runs your command. Secrets never touch disk as plaintext. As a bonus, op run automatically masks secret values if they accidentally appear in stdout.

Setup is a one-time thing. You create a vault item with your secrets (the demo repo includes a setup script for this), customize the references in .env.1password, and you’re done. Every developer on the team can share the same .env.1password file in version control and resolve it against their own 1Password account.

Or macOS Keychain

Not everyone uses 1Password, and that’s fine. If you’re on a Mac, you already have a secrets manager built into the OS. The security command can read and write to your login keychain, and macOS gates access with your password or Touch ID.

The wrapper script reads each secret from Keychain and exports it.

#!/usr/bin/env bash
declare -A SECRETS=(
  [API_KEY]="secure-env-demo/api-key"
  [DATABASE_URL]="secure-env-demo/database-url"
  [WEBHOOK_SECRET]="secure-env-demo/webhook-secret"
)

for var in "${!SECRETS[@]}"; do
  service="${SECRETS[$var]}"
  value=$(security find-generic-password -a "$USER" -s "$service" -w)
  export "$var=$value"
done

exec "$@"

Storing a secret is one command.

security add-generic-password -a "$USER" -s "secure-env-demo/api-key" -w "sk-your-key" -U

It’s a bit more manual than the 1Password approach — you maintain the mapping in the script rather than a reference file — but it works without any third-party dependencies.

What you gain

The immediate benefit is obvious — no more plaintext secrets on disk. But there are a few less obvious wins.

One source of truth. When a credential rotates, you update it in one place. Every project that references it picks up the change automatically.

Onboarding gets simpler. Instead of “here’s the .env file, don’t lose it,” you say “set up 1Password and run the setup script.” The secrets are in the vault with proper access controls.

Auditing. 1Password and Keychain both maintain access logs. You can see who accessed which secrets and when. A .env file gives you none of that.

It works with anything. The wrapper pattern is language and framework agnostic. ./with-1password.sh docker compose up works just as well as ./with-1password.sh pytest.

What about other tools?

There’s a whole ecosystem of secrets management tools — Doppler, Infisical, HashiCorp Vault, SOPS, dotenvx. They’re all good, and if you’re running a team of 50+ engineers you should probably be evaluating them.

But for most developers working on personal projects or small teams, the 1Password or Keychain approach hits a sweet spot: minimal setup, no infrastructure to manage, and you’re probably already paying for the tools.

The important thing isn’t which tool you pick. It’s the pattern. Store secrets in a vault, inject at runtime, never write plaintext to disk.

Try it

The secure-env-demo repo has everything you need to try both approaches. Clone it, pick the one that fits your setup, and run the demo app:

git clone https://github.com/jonmagic/secure-env-demo.git
cd secure-env-demo

# 1Password path:
./setup-1password.sh
./with-1password.sh ./app.sh

# Keychain path:
./setup-keychain.sh
./with-keychain.sh ./app.sh

It’s a small change to how you work, but once you do it you won’t go back. Every time I see a .env file now I think about that conversation in the Tesla and wonder why I didn’t do this years ago.

A Practical Guide to Writing with AI

2026-02-13T00:00:00Z

I use AI in my writing all the time. For research, for turning messy transcripts into coherent sentences, for drafting, for getting feedback. But the way I use it matters. This isn’t about handing the wheel to an AI and publishing whatever it spits out. It’s a collaboration, a conversation, where the AI assists me and I stay in the driver’s seat.

I’ve been refining this process over the past year and sharing bits of it in PR reviews, Slack threads, and conversations with colleagues. Here’s the full picture.

Why bother with a process?

There’s a real tension around AI-written content right now. A colleague put it well: “Why should I bother to read something someone else couldn’t be bothered to read?” And she’s right. If you feed a prompt into an AI and publish the output without reading it yourself, people can tell. The writing feels strenuous to parse, slightly off, like a conversation with someone who knows all the words but none of the stories.

I’ve gotten feedback on my own writing from people who know I use AI heavily. The honest ones say they can sometimes tell. But the feedback I hear most is that my writing feels like me, and I think that’s because of how I use AI, not whether I use it.

The goal is writing that a reader experiences as human, thoughtful, and worth their time, even though AI was deeply involved in creating it.

Step 1: Collect all your context in one place

Before I write anything, I gather everything related to the topic. This sounds obvious but it’s the step most people skip, and it’s the one that makes everything else work.

What I collect:

Transcripts from every conversation I had while working on the thing
Research I did along the way
Slack conversations
Links to all related issues and PRs
Screenshots and diagrams
Transcripts from walk and talks where a lot of my initial ideation and final prose takes shape

This sounds like a lot of work, and it can be at first if you haven’t developed a habit around collecting these things as you go. All of my workflows center around collecting artifacts in my Brain folder (a personal knowledge base), so by the time I sit down to write it’s as simple as “please collect all my context on topic X” and the agent does the work for me.

In my experience the quality of AI-assisted writing is directly proportional to the quality of context you give the AI. Garbage in, garbage out. Rich context in, rich writing out.

Step 2: Organize and find your story arc

Give all the context to an agent and ask it to help you organize it. Then ask for a few pitches with story arcs.

For agents, I use whatever fits the moment. Right now my go-to is an agent called OpenCode, but I also use Copilot CLI, and Copilot in VS Code. The tool doesn’t matter much. What matters is giving it the full picture and asking it to help you see the shape of the story.

Here’s something I’ve learned the hard way: AI-generated story arcs can feel samey. People who read a lot of AI-assisted writing start to recognize the patterns — the “journey from X to Y” structure, the tidy three-act narratives. The arcs aren’t bad, but they’re recognizable, and recognizable is the opposite of what you want.

So I’ve been leaning more into interview mode. Instead of asking the agent for story arc pitches and picking one, I ask it to interview me about the topic. Agents are surprisingly good at interviewing and it often gets me to think about things I hadn’t considered. Questions like “what surprised you most about this work?” or “who was the audience you kept thinking about?” pull out the narrative I was carrying in my head but hadn’t articulated. The arc that emerges from an interview is yours — it has your emphasis, your surprises, your priorities — and that’s much harder for a reader to clock as AI-shaped.

You can still ask for pitches if you want a starting point. Just be aware that the more the structure comes from the AI, the more it’ll read like AI. If none of the arcs feel right, give it that feedback. Ask for more ideas, or give it some of your own. But when I want the piece to really feel like mine, I start with the interview.

Step 3: Get the rough draft

Once you have a story arc figured out you can either write it by hand or ask the agent for a rough draft. I usually ask for a rough draft, including placeholders for diagrams or pictures.

I get pretty good results from rough drafts, but that didn’t happen by accident. Over time I’ve built up a “voice and tone” profile that includes examples of my writing along with the principles I apply when I write. The examples come from things I’ve published on my blog and elsewhere. This gives the AI a concrete target to aim for rather than its default style.

If you don’t have a voice profile yet, you can start by giving the agent three or four pieces of your own writing and saying “match this tone.” It’s not as refined as a full voice guide but it gets you most of the way there.

Step 4: The editing conversation

This is where the real work happens, and it’s what separates writing that feels human from writing that feels like AI slop.

If the agent wrote the draft: Go sentence by sentence and create a list of feedback. You can just edit things yourself manually, but if it’s going to need major rework it’s often better to give the AI all that extra context. Make this a conversation or an interview.

If you wrote it yourself: Ask the agent to give you feedback. It’ll catch repetition, unclear transitions, and structural issues you’re too close to see.

Things I watch for in AI-generated prose, from specific feedback I’ve given on real PR reviews:

Repetition of themes. AI loves to hammer a point home across multiple sections. In a recent review I flagged that the same arc (“this went from painful to boring”) appeared in three separate sections. Once is powerful. Three times is a newsletter.
The colon tell. Phrases like “If you’ve ever been near infrastructure, you know: DDoS isn’t theoretical” are an AI fingerprint. Turn colons into commas, or better yet rewrite those portions. A caveat: some people naturally write with colons, so this is only a tell if it’s not already part of your style. These stylistic fingerprints cut both ways. AI introduced me to em dashes and now I genuinely love using them, so I give myself a pass. A colleague who always used em dashes told me she’s been trying to break the habit now that AI overuses them. The point isn’t to avoid specific punctuation — it’s to know your own patterns well enough to tell the difference between your voice and the AI’s.
Headers that try too hard. Story-arc headers like “The Turning Point” or “Why Everything Changed” can feel less human. Simple, direct headers work better.
Read it out loud. If a section doesn’t sound like something you’d actually say, make small tweaks until it feels like you. This is the single most effective editing technique I’ve found.

Step 5: The voice memo trick

For writing that really needs to sound like you, I use a technique that’s become central to my process.

I use the Voice Memos app on my phone to record myself talking through the story at a high level, just the natural flow of how I’d explain it to someone. Then I take the transcription and use it as a base to write from. This gets my natural storytelling rhythm into the writing in a way that typing from scratch often doesn’t.

Then I lean heavily on AI for research, writing and rewriting small sections. When I hit the detailed parts of the story, I do more voice recordings to capture the nuance, then use those transcripts to refine the writing.

The result is prose that has my actual cadence and phrasing baked in at the structural level, with AI handling the polish and filling in details I’d otherwise spend hours looking up.

Step 6: Human review

Give it to another human now that you’ve checked all your work and the agent’s work. Get their feedback. This step is non-negotiable. AI can’t tell you if your writing resonates with a real person. Only a real person can do that.

Step 7: Publish

Mash that publish button.

The underlying philosophy

I use AI more for research and outlining than for final content. The finished piece has large portions written by me. I sometimes joke that AI was designed to just sound like me, but the truth is I’ve put deliberate work into making the collaboration seamless.

The people who are frustrated with AI writing, and they have every reason to be, are reacting to writers who aren’t doing the work. They’re not reading their own output. They’re not editing. They’re not bringing their own voice to the table. And readers can feel it.

Writing with AI is a collaboration. The AI brings speed, research capability, and tireless willingness to try different framings. You bring the stories, the judgment, and the voice. Neither one works well without the other.

The skill that matters isn’t “prompting” or “using AI.” It’s learning how to have a productive conversation with a collaborator who has perfect recall and no taste. That’s a skill worth developing.

Securing My Home Network with AI

2026-02-08T00:00:00Z

I spent the weekend making my home network more secure, and the whole thing was just a conversation.

Not “I asked an AI to generate a security checklist and then went through it.” More like: I sat down with a CLI agent, started talking about my network, and kept going. Over the next several hours, we port-scanned the network, audited what was exposed, hardened the NAS, built documentation crawlers, wrote an 8-phase improvement plan, and generated 24 Markdown docs from the Synology API. I never opened a browser to search for how to do any of it. I just kept talking.

I’ve been thinking a lot about designing collaborations rather than just automations, and this project turned out to be the most fun example yet. The AI did the coding. I made the decisions. And the project harness we built along the way kept getting smarter.

The Setup

My home network is the usual story of accumulated decisions. Fiber into a gateway in IP passthrough mode, feeding a mesh router, serving about 46 devices on a flat network. A Synology NAS running Docker containers for game servers, an nginx reverse proxy, Let’s Encrypt cert management, and a few other things.

One of the first things the agent generated was a topology diagram. Here’s a simplified version with fake addresses:

Internet
  │
  ▼
┌──────────────┐
│   Gateway    │  passthrough mode
│  (fiber ISP) │
└──────┬───────┘
       │
┌──────┴───────┐
│  Mesh Router │
│  + 2 sats    │
└──────┬───────┘
       │
       ├── NAS
       │    ├── Docker: nginx reverse proxy (TLS)
       │    ├── Docker: game servers
       │    ├── Docker: certbot (Let's Encrypt)
       │    └── Tailscale VPN
       │
       ├── Laptops, phones, tablets
       ├── Smart TV, streaming devices
       ├── IoT: smart plugs, cameras, sensors
       └── ... ~40 more devices

Having this in a version-controlled Markdown file—generated from the conversation—turned out to be surprisingly useful. It became the reference point for every decision that followed.

I’d been meaning to audit the whole setup for a while. Not because anything was broken—everything worked fine—but because I’d been port-forwarding and enabling services for years without ever going back to see what the cumulative result looked like. It was a weekend project I kept not starting.

What made it fun this time was the format. Instead of researching and executing solo, I opened OpenCode—a CLI coding agent—and just started a conversation.

Just Keep Talking

The first thing I said was something like “help me understand what’s exposed on my network.” The agent ran nmap, parsed the results, and we talked through each open port together. Some were intentional (the game server, the reverse proxy). Some were not—services I’d never intentionally exposed to the internet. We built a security audit document right there in the conversation, categorizing everything by severity.

Here’s roughly what that audit looked like (with fake details):

External Port Scan Results
──────────────────────────
PORT      SERVICE                 STATUS
xx/tcp    reverse proxy (HTTP)    ✓ Intentional
xx/tcp    reverse proxy (TLS)     ✓ Intentional
xx/tcp    game server             ✓ Intentional
xx/tcp    storage replication     ✗ NOT INTENTIONAL
xx/tcp    admin UI                ✗ NOT INTENTIONAL
xx/tcp    discovery service       ✗ NOT INTENTIONAL

Risk: 3 services exposed that should only be reachable on LAN

Seeing it laid out like that made the problem concrete. Three ports I’d never meant to expose, sitting there for who knows how long.

What surprised me was how much I was learning just by talking it through. I work on GitHub’s Safety & Integrity team building infrastructure for abuse prevention at scale, but at home I didn’t have runbooks or institutional knowledge. The conversation replaced all of that. I’d ask “what does this service do and why would it be exposed?” and the agent would explain, and then I’d decide what to do about it. It felt like pair programming with someone who happens to know every Synology forum post ever written.

From that first scan, the conversation just kept going. We narrowed the port forwarding rules on the router. We disabled remote management on the Orbi. We started on the NAS. Each thing led naturally to the next thing, and I never had to context-switch to a browser or a different tool.

The Project Harness

A few sessions in, I realized this was becoming a real project. So I did what I’d do at work—I gave it structure.

I set up a repo with three kinds of content: reference docs generated by crawlers and API scripts (snapshots of every device’s current configuration), plans for multi-step work like NAS hardening, and agent skills that teach the agent how to operate specific parts of the network.

The skills are the fun part. Each one is a Markdown file that gives the agent context about a specific piece of the network. How to SSH into the NAS, which auth method to use. Where Docker containers live on disk. What the network topology looks like. When the agent loads a skill, it has the context to actually do things safely instead of guessing.

Here’s what made this feel different from other AI projects I’ve done: the skills grew out of the conversation itself. Every time the agent needed information it didn’t have—or made a wrong assumption—we’d write that knowledge into a skill file. This is the improvement loop pattern applied to infrastructure instead of code.

Some of the skills we ended up with:

nas-manage: Connection details, storage layout, Docker container inventory, and a note that the root filesystem sitting at 90% is normal (so the agent doesn’t flag it as a problem every time).
network-monitor: Ping sweeps, port checks, service availability commands.
network-config: How to query the router and gateway using their crawled documentation.
crawl-device: How to re-crawl each device’s UI to regenerate docs after making changes.
improvement-loop: The systematic process for turning agent mistakes into permanent fixes.

Skills vs. docs — a work in progress. The line between “this is a skill” and “this is a doc” is still blurry. Skills are addressed to the agent: “when asked to do X, here’s how.” Docs are records of state: “here’s what the network looks like right now.” But in practice, skills embed reference data (IPs, device tables) so the agent can act without extra lookups, which means that data lives in two places. And some docs contain step-by-step instructions that read like skills. The pragmatic rule we landed on: if the agent needs it to do something, it’s a skill; if it exists as a record, it’s a doc. But I’d like to tighten this up — probably by having skills link to docs for reference data instead of duplicating it.

By the later sessions, the agent could SSH into the NAS, check a configuration, and update the documentation without me explaining anything. The harness had absorbed enough context to be genuinely useful.

NAS Hardening: The Fun Bits

The NAS hardening was the meatiest part. We wrote a 10-step plan and worked through it together. Most of it was straightforward—disable SSDP and Avahi, tighten Auto Block, raise the password policy, enforce 2FA. The agent would suggest a change, explain why, and I’d apply it through the DSM UI while the agent verified from the command line.

But a few moments were genuinely entertaining.

The SSH near-lockout. We were hardening sshd_config—disabling password auth, requiring keys only—and at one point PubkeyAuthentication got set to no instead of yes. Which would have locked me out of my own NAS. Except the agent had suggested earlier in the conversation that I keep a backup SSH session open while making changes. So I did. And that backup session saved me. The lesson went straight into an operational notes doc, and now the nas-manage skill includes a reminder to always keep a backup session.

The rsync mystery. After SSH hardening, every deploy script I have broke. Multiple projects use rsync over SSH to deploy to the NAS, and suddenly none of them worked. We dug into it together and discovered that Synology’s rsync binary is setuid root and uses PAM for authentication—even when it’s invoked over an already-authenticated SSH session. Disabling the Synology rsync service had broken the PAM chain. The fix was simple (re-enable the rsync service), but finding it would have been a solo debugging nightmare. In the conversation, we traced through the PAM config, checked the binary permissions, and figured it out in maybe ten minutes. That one went into the operational notes too.

The 2FA cascade. After we enabled TOTP for all NAS accounts, the documentation crawl script stopped working because the Synology API now required an OTP code for authentication. That one’s still on the todo list—we noted what broke and moved on. I like that the conversation naturally captured the dependency so future-me won’t have to rediscover it.

Documentation Just… Appeared

This is the thing I keep coming back to. I didn’t set out to document my network. I set out to make it more secure. But because the conversation naturally involved checking configurations, running API queries, and verifying changes, documentation fell out as a side effect.

The NAS crawl script hits 80+ Synology API endpoints, and a Python script turns the JSON responses into 24 readable Markdown files covering security, network, Docker, file services, packages, and more. Every time we changed a setting, the natural next step was “let’s re-crawl and make sure the docs reflect reality.” So we did.

For the Orbi router and AT&T gateway—which don’t have APIs—we built Playwright crawlers that log in, navigate every page, take screenshots, and generate Markdown from the page content. Version-controlled snapshots of every device’s configuration that I can diff over time.

The improvement plan became a living document too. Eight phases, from the emergency port-forwarding fixes we’d already done through future work like VLAN segmentation, Pi-hole DNS, and a monitoring stack. Each phase has scope, success criteria, and links to the relevant skills and docs. It’s the kind of planning document I’d write for a project at work, and having one for my home network feels like an unexpected luxury.

My Favorite Artifact

The operational notes document is my favorite thing we produced. It’s a single file capturing every hard-won lesson:

Synology rsync is setuid root and uses PAM—keep the rsync service enabled or deploys break.
DSM’s “HSTS” checkbox only enables HTTP-to-HTTPS redirect, not the actual Strict-Transport-Security header.
NetBIOS has no separate toggle in DSM 7—it’s tied to the SMB service.
Docker needs the full /usr/local/bin/docker path for non-interactive SSH sessions.
The default-deny firewall rule also blocks ICMP, so add an explicit allow if you want ping monitoring.

Each one of these is the kind of thing you’d find buried on page three of a forum thread. Having them in a version-controlled file means I won’t rediscover them the hard way, and the AI agent can reference them in future sessions. The knowledge compounds.

Why This Was Fun

I think what made this project work—and what made it fun instead of tedious—comes down to a few things.

It was a conversation, not a checklist. I didn’t have to plan everything up front and then execute. I just started talking, and the work emerged naturally. Each discovery led to the next question, which led to the next change.

The project got smarter as we went. Every skill we wrote, every operational note we captured, every doc we regenerated made the next session easier. By the end, the agent had enough context about my network to be a genuinely useful collaborator rather than a generic assistant.

The outputs were varied and interesting. We weren’t just toggling settings. We were building crawlers, writing shell scripts, debugging PAM authentication, designing firewall rules, generating documentation. The variety kept it engaging in a way that grinding through a hardening guide wouldn’t have been.

I stayed in the loop without drowning in details. I wasn’t reviewing individual lines of code or verifying command syntax. I was reading the documentation the agent generated, following its explanations of what each change would do, and making decisions based on that. The whole interaction happened in natural language rather than code, which meant I could focus on understanding my network instead of wrestling with configuration syntax. It’s a different kind of understanding than reading every line yourself, but it’s real—and it’s the reason I’d feel confident making changes on my own now.

What’s Next

The external attack surface is down to three intentional ports and one annoying DNS issue that needs an architecture change to fix. Router hardening is done—at least as far as the Orbi lets us go. The remaining phases are VLAN segmentation, Pi-hole, monitoring, and eventually some hardware upgrades.

I’ll keep working through them the same way: start a conversation, let the work emerge, encode what I learn into skills and docs as I go. The harness gets better every session, so each phase should be smoother than the last.

If you’ve been putting off a project like this because it feels like a slog, try making it a conversation instead. It’s a different experience entirely.

My First 30 Years in Tech

2026-01-30T00:00:00Z

I turned 44 recently, which means I’ve now spent exactly half my professional life as an entrepreneur and half as an employee. Fifteen years building and running my own businesses, followed by fifteen years working for others. The symmetry wasn’t planned, but it’s given me a chance to reflect on what I’ve learned about myself along the way.

The Foundation

I fell in love with computers when I was five years old. My dad worked at a Kenworth dealership in Florida, and on one visit to his office I got to play Frogger on their ancient machine—probably pre-8088. I thought it was the most amazing thing I’d ever seen.

When we moved to Michigan, my Uncle John started giving me leftover computer parts from his repair business and swap meets. I’d assemble whatever I could from the scraps. Somewhere around age nine, I entered a home-built PC in the county fair through the 4-H program. I won every award in that category, mostly because I was the only person who had ever entered a computer.

I come from a family of entrepreneurs. My parents had full-time jobs, but they also ran side businesses—my mom did desktop publishing, my dad was a general contractor. I was homeschooled, which meant I learned to teach myself early. I didn’t actually learn to read until I was eight, but once I did, you couldn’t stop me.

By eleven or twelve, I was working part-time for my dad’s construction business. If I finished my schoolwork by lunch, I could go swing a hammer at whatever house he was building or renovating. I learned what hard work looked like, and I learned that you could make your own way.

The Entrepreneur Phase

At fourteen, my best friend Christian Metts and I decided to start a virtual reality arcade. This was 1996. We wrote a business plan, raised $10,000 from family and friends, and set up shop in the Jackson Crossing Mall in Jackson, Michigan—right near the nail salon and pet store.

We had a couple PCs with VFX1 headsets running a game called Descent. It was pretty cool for the time. But that same summer, the Quake demo came out. We spent more time playing Quake than we did selling our service to mall passersby. The business failed by the end of summer. We paid back our investors by working for my dad, swinging hammers and helping build storage units.

That failure didn’t stop me. I’d already been teaching people how to use computers in exchange for things like horseback riding lessons. I started Legend Computer Services and began doing IT consulting for friends, mostly other homeschool families. After high school, I went to work for a local IT shop. The lead technician quit a few days after I started, so I went from filling ink cartridges to repairing PCs almost overnight.

The owner was difficult to work for, so I quit a few times and kept doing my own consulting. But I kept going back because I could make more money there than on my own. Eventually I left for good, taking a chunk of the client base with me.

In 2004, I teamed up with Brad Cochran to buy SabreTech Consulting from a friend who was struggling to make it work. We knew how to make it succeed. A few years later we added Sam Sallows as a partner, and by 2010 we’d grown the business to over a million dollars a year in PC sales and services.

The Pivot

Everything changed in 2006 when Christian Metts—same friend from the VRcade days—introduced me to Ruby on Rails. I went to the first RailsConf in Chicago that year and caught the programming bug. We started building software for SabreTech customers: a billing sync system for a chain of tanning salons, an obituary website called Forever Remember Me, internal tools for our own operations.

In 2007, my wife Natalie and I got married and moved to Elkhart, Indiana. I searched for “ruby south bend” and found a meetup at Notre Dame. That’s where I met John Nunemaker and Steve Smith.

We started hanging out regularly, hacking together at a place called Fiddler’s Hearth in South Bend. One day they were complaining about Slideshare. One of us said, “If it sucks so much, why don’t we build our own?” I pulled out my laptop, figured out how to convert PDFs to images with ImageMagick, and Speaker Deck was born.

Steve and John had started a company called Ordered List. They were building products like Harmony (a CMS) and doing consulting work. In late 2010, they offered me a job.

This was a big decision. I’d been an entrepreneur for fifteen years. The idea of working for someone else felt foreign. But with Natalie’s support, I sold my share of SabreTech to my partners and joined Ordered List in December 2010. Brandon Keepers joined a few weeks later, then Matt Graham a couple months after that.

The GitHub Chapter

Our small team built Gauges (a web analytics tool), maintained Speaker Deck and Harmony, and paid the bills with consulting work—including helping Zynga build Words with Friends for Facebook.

GitHub noticed our products and our work. They made an offer to acquire Ordered List. On December 5th, 2011, all five of us joined GitHub. I became employee #50.

I’d been an early GitHub user—user ID 623, signed up on February 22nd, 2008—back when the platform first launched. Being part of the Ruby community meant you found out about GitHub quickly. Now I was an early employee too, just three years into the company’s life.

The Realization

I’ve now been at GitHub for fourteen years, and an employee for fifteen. The symmetry with my entrepreneur years is complete.

Here’s what I’ve discovered: I love building software more than I love running a business. But it’s more specific than that. I love building teams that solve people’s problems through software.

At GitHub I’ve had the chance to serve our support team, finance team, sales team, product team, and security team by designing, planning, building, and maintaining software. I’ve built and led teams. I’ve found my calling.

But it’s not just the work—it’s where I get to do it. I’ve interviewed at other companies every few years since joining GitHub, and I keep choosing to stay. There’s something special about being at the center of the software universe. I love helping developers—and people who don’t yet know they’re about to become developers—discover and invent a new world. GitHub brings people together. It gives them the opportunity to do meaningful work through collaboration by solving problems together. It’s hard for me to explain the fulfillment I get from contributing to the open source projects and the infrastructure that power everything from research to startups to enterprises—and through protecting that community so it can thrive.

Software development is my calling and GitHub is a huge part of that—and a central part of my identity.

I don’t have grand lessons to share. Just this: reflection matters. I didn’t know what I truly loved until I’d spent fifteen years doing one thing and fifteen years doing another. Sometimes you have to live both paths to understand which one fits.

I hope I get another thirty years doing this work. I want to keep waking up every morning trying to figure out the next cool problem to solve with technology—without necessarily having to worry about all the details of running a business. I want to focus on building teams that help people.

That’s what the first thirty years taught me about myself.

Turning Agent Misses into Systemic Improvements

2025-12-30T00:00:00Z

Over the holiday break I decided to rebuild a slice of an internal web app from my day job as a webview experience inside VS Code. The goal wasn’t really the feature itself—it was to force myself to learn the VS Code extension APIs and to get my hands dirty with Open Truss, an open-source workflow framework I’ve been collaborating on with @hktouw and @kmcq.

I started where I usually do: drafting a plan, spinning up a workspace, and asking Copilot to start coding. But as I worked I got annoyed with doing things the way I’ve been doing them the past year—constantly steering the agent, pasting browser console errors, describing visual bugs, and nudging it back on track. The loop I’d used for most of 2025 now felt too fragile.

Then I watched this interview about SKILLS.md in Copilot, learned about the Ralph Wiggum AI technique, read Niklas Heidloff’s post from March 2025 on why agents fail, and Steve Krenzel’s piece on the infrastructure tax teams should pay, and a few things started to click.

The Shift

I was spending more time debugging the agent than building features. The loop went like this: prompt Copilot, review the output, find the bug, explain what went wrong, try again. I was the debugger, and every iteration took seconds or minutes because I had to context-switch between the code, the terminal, and the running VS Code extension.

Then I changed one thing. Instead of just fixing what broke, I started asking: what didn’t the agent see?

If it hallucinated a GraphQL field, the schema wasn’t visible. If it picked the wrong component, the registry docs were incomplete. If the layout looked wrong, there was no visual gate. Each failure pointed to missing observability or incomplete instructions.

So I stopped treating agent misses as bugs to fix and started treating them as gaps to close. Every mistake became a reason to add a test or eslint rule, document a pattern in a skill, or tighten the instructions. The work shifted—less “write this code for me” and more “here’s how to see when you’re wrong.”

A Little Setup

Before we dive into the examples below let me explain a bit about the project I was working on. It’s a web-based Kafka consumer monitoring tool that engineer first responders use to debug stream processing issues—checking consumer lag, partition assignments, offset tracking, etc.

The existing web app worked fine, but it lived in a browser tab that engineers had to context-switch to. I wanted to bring those affordances into the editor closer to where the changes to address issues actually happens. Click a consumer name in your code, see its current state, jump to logs or metrics—all without leaving VS Code.

I think about the intersection of internal tools and AI a lot, so this project was a good fit to see how deeply I can integrate agents and mcp tools into the workflows my stakeholders (analysts, support staff, first responders) use every day. I chose Open Truss because we designed it to empower non-engineers to build internal tools with minimal coding, and I wanted to see how AI agents could help fill in the gaps.

I also setup this particular project with three distinct agents:

The Planner: An agent that breaks down high-level feature requests into discrete implementation steps.
The Implementer: An agent that writes the code based on high-level feature requests.
The Reviewer: An agent that reviews the Implementer’s code for correctness, style, and adherence to best practices.

Turning Misses into Hits

Here are a few examples of how I turned agent misses into systemic improvements that made future iterations smoother.

Example 1: Hallucinated GraphQL Fields

The first systemic failure showed up early. The Implementer built a consumer list workflow and wrote a GraphQL query to fetch consumer data:

query AppConsumers {
  appConsumers {
    consumers {
      consumerName
      groupId
      status        # ✗ ERROR
    }
  }
}

When I ran the workflow, it crashed with a schema error:

[GraphQL] Cannot query field "status" on type "AppConsumer"

I asked Copilot to help me understand what went wrong. It found that the status field existed on the parent response object (AppConsumersResponse), not on individual consumers.

I could’ve just asked Copilot to fix the query and moved on. Instead, I asked: what’s preventing the agent from seeing this before it writes the code?

The schema file lived in generated/schema.graphql—96,000 lines synced from the backend. The agent wasn’t checking it. So I asked Copilot to build a skill that codified the validation workflow:

From .github/skills/graphql-schema-validation/SKILL.md:

## Critical Rule
**ALWAYS verify GraphQL queries against the actual schema before implementation.**

### Step 4: Search the Schema
Use grep to find type definitions:

# Find a type definition
grep -A 10 "^type AppConsumer {" generated/schema.graphql

Example output:

type AppConsumer {
  consumerName: String!
  groupId: String
  topic: String!
}

Notice: No status field exists on AppConsumer.

Then I had Copilot add it to the agent instructions:

- **GraphQL queries**: Always validate against the schema before writing queries.
  Use grep to verify field existence on target types. Never assume field availability.
  See `graphql-schema-validation` skill.

The next time the Implementer needed to write a query, it ran grep -A 10 "^type ConsumerPartition {" generated/schema.graphql first, saw which fields actually existed, and got it right. No hallucinations. No runtime crashes.

Example 2: Stale Renders from Missing `useSignals()`

A few days in, I noticed a pattern. The agent would build a component that read from a signal prop—say, a table that displays consumer data from :consumerData—and the table would render once with empty data, then never update when the signal changed.

Here’s what the component looked like:

export function ConsumerTable({ dataSignal }: { dataSignal: { value?: Consumer[] } }) {
  const data = dataSignal?.value ?? []
  return (
    <Table>
      {data.map(row => <TableRow key={row.id}>{row.name}</TableRow>)}
    </Table>
  )
}

The data would load, the signal would update, but the table stayed frozen on “No data found.”

The problem: Open Truss signals use Preact signals under the hood. React doesn’t automatically subscribe to .value changes unless you call useSignals() at the top of the component (at least the way we’re using it right now). Without it, you get stale renders.

I could’ve just added the hook and moved on. But I’d already debugged this three times that week. So I asked: how do I make this failure impossible?

Copilot updated the component-wrapper skill with a clear warning:

From .github/skills/open-truss.component-wrapper/SKILL.md:

### ⚠️ Signal-aware components MUST call `useSignals()`

If a component **reads or writes any signal prop** (props passed as `:signalName`),
call `useSignals()` at the top of the function body **before** deriving values or rendering.

import { useSignals } from '@open-truss/open-truss'

export function MySignalConsumer({ valueSignal }: { valueSignal: { value?: string } }) {
  useSignals()  // ← Required for reactivity
  const value = valueSignal?.value ?? ''
  return <div>{value}</div>
}

Missing `useSignals()` leads to stale renders (tables showing "No data found",
badges not updating, etc.) even though the signal value changes.

And it added it to the checklist at the bottom of the skill:

- [ ] `useSignals()` is called when any prop is a signal reference (reads/writes `:signalName`)

After that, every new component got it right on the first try. The agent would see the warning, add the hook, and the stale render bug vanished.

Example 3: Test Harness First, Features Second

Manual testing was killing me. I’d ask the agent to build a feature, press F5 to launch the VS Code development window, click around, find a bug, describe it back to the agent, and repeat. The loop took seconds of my time per iteration.

I asked Copilot to build a Playwright harness that ran Open Truss workflows in a real browser, mocking the VS Code boundary. Now every workflow got a co-located test file that ran before I ever opened VS Code:

// workflows/consumer-detail.test.ts
test('detail tab opens with correct args', async ({ page }) => {
  // Listen for VS Code command before clicking
  const commandPromise = page.evaluate(() => {
    return new Promise((resolve) => {
      window.addEventListener('vscode-command', (e: any) => {
        resolve(e.detail)
      }, { once: true })
    })
  })

  await page.click('[data-testid="consumer-row-1"]')

  const command = await commandPromise
  expect(command.command).toBe('app.openWorkflow')
  expect(command.args.workflow).toBe('consumer-detail')
  expect(command.args.consumerName).toBe('signal-processor')
})

This became a gate: the Implementer couldn’t claim a feature was done until this test passed. No test, no merge. The payoff showed up immediately—test failures told me exactly which assertion broke, not just “it doesn’t work.”

Example 4: Visual QA Catches What DOM Assertions Miss

After getting tests passing, I kept finding AI generated UI slop that DOM checks couldn’t catch: large gaps between components, weird alignment, UI that just didn’t make sense. So I asked Copilot to add a visual QA step leveraging the llm cli:

test('consumer badges have consistent spacing', async ({ page }) => {
  const screenshot = await page.screenshot()

  const result = await runVisualQA({
    screenshot,
    criteria: [
      'Status badges have 16px horizontal gap between them',
      'No badges overlap or clip',
      'Badge text is readable and not truncated'
    ],
    model: 'gpt-4.1'
  })

  expect(result.verdict).toBe('pass')
})

The runVisualQA function captures the screenshot and pipes it to a headless reviewer that checks for overlap, clipping, and visual affordances. Now visual correctness became data, not vibes. Copilot even added this to the workflow spacing skill so future implementations got it right from the start.

You should disable this for CI unless you like to 🔥💵

What I Learned

Over the last few days of this project, I shipped roughly equal amounts of features and guardrails. Looking at the git log, the commits cluster into three arcs:

Features: Kafka consumer monitoring, list/detail splits, templated links, new tab routing
Observability + guardrails: Visual QA hooks, workflow spacing standards, registry validation tests
Enablement plumbing: Composite builds, schema sync, test harnesses, agent skills

The payoff was measurable. Human-in-the-loop density dropped from every few minutes to once per slice. The Implementer could take a high-level feature request and deliver working code with minimal back-and-forth. The agents made fewer mistakes because they could see their failures.

Each failure turned into improved observability, a new skill, or clearer instructions. Those improvements compounded. By week two, features that would’ve taken five to ten rounds of steering are landing in one or two.

What’s Next

Now I’m teaching my implementation and review agents to tell me about ways to improve themselves. I want them to suggest updates to the skills they use. The goal is a self-improving AI collaborator that gets better at building software with each iteration, not just faster at writing code.

A lot of the vocal community is exploring memory systems—databases that persist agent context across sessions, semantic search over past decisions, knowledge graphs of what was learned. That approach treats agent failures as a recall problem: if only the agent remembered the last time it made this mistake, it wouldn’t repeat it.

For now at least I’m going the opposite direction. Every time the agent sees my project with fresh eyes, it’s testing whether the codebase is clear enough to guide a newcomer. If it keeps hitting the same GraphQL field hallucination, that’s not a memory gap—it’s missing observability. The schema validation skill I built isn’t a workaround for forgetfulness; it’s a permanent improvement that makes that entire class of failure impossible.

If you’re building with agents, stop trying to prompt your way out of the same agent misses over and over. Build the observability they need to see the world clearly and the skills to improve themselves.

How I Work, 2025 Edition

2025-12-16T00:00:00Z

I took this week off to reflect and spend some time closer to the mountains as I start my forty-fourth year on this planet. One of the things I’ve been thinking about and have been meaning to write about is how my processes and tools have evolved over the past two decades.

Most productivity systems, the processes and tools, optimize for the wrong brain—someone else’s. I spent years trying to adopt systems that worked for the people I look up to because of their brilliance and productivity but time after time I abondoned the prescribed workflows. They just didn’t stick for one reason or another.

Eventually I realized that my brain, not theirs, is what I should be designing for. I still look to others for new ideas and optimizations but now I time box my evaluation and then adapt or abandon.

That is probably one of the most important things I can share in this post, that optimizing how you work isn’t something you tackle in a weekend and then you’re done. It’s a marathon of experimentation, reflection, and adaptation.

Our brains are constantly changing as they consume new information, and we experience chemical changes due to aging, so the process is necessarily lifelong and iterative. The tools and processes that work for you today may not work for you in a year or two. You have to keep tuning and adapting.

This post is a reflection on how I work at the end of 2025, some of it new, but lots of it old.

Two Mental Frameworks I Consistently Use

There are two primary frameworks I use day to day, week to week, month to month, and year to year to keep myself organized and productive.

PRIME

Five verbs shape my week. I use them to guide my weekly planning and daily execution.

Plan: Reduce ambiguity by formulating a narrative arc and naming what “better” looks like.
Refine: Shorten loops by improving tools, templates, and paved paths.
Integrate: Connect efforts across teams, carry context, and make status legible.
Mentor: Grow people via pairing, reviews, and unblocking; learn out loud together.
Execute: Ship the smallest credible artifact that forces a decision.

These five words are somewhat of a mantra for me (a term I first learned about from Guy Kawasaki more than two decades ago). My mantra from 2020 to 2024 was “I will listen, I will learn, I will teach, and I will serve”.

It sounds silly but this little exercise has helped me maintain focus throughout a day, a week, a month, and even a year or more. My brain spends less time traveling down counter producive paths when I can return to these five words to reorient myself.

SWOT

My mantra is a direct result of me consistently analyzing myself using a framework like SWOT (Strengths, Weaknesses, Opportunities, Threats). When I first learned about the SWOT analysis framework in college I started applying it once or twice a year to my personal and professional life with great results. Over time I’ve used it more frequently to the point where it’s part of my daily mental model driving how I think and make decisions.

There are other great frameworks like SOAR (Strengths, Opportunities, Aspirations, Results) that focus more on the positive. SWOT always stuck for me because I learned it first but I think the important thing is finding a repeatable mental model that helps guide decisions and trade-offs consistently.

My Workflow

My workflow centers on a single folder I call my brain—a directory of Markdown files that starts with a Weekly Notes/Week of <yyyy-mm-dd>.md file for each week which then flow into Meeting Notes/<handle>.md files, which wikilink to Transcripts/<yyyy-mm-dd>/<nn>.md and Executive Summaries/<yyyy-mm-dd>/<nn>.md files, and then into Daily Projects/<yyyy-mm-dd>/ folders for day-level scratchpads and context dumps.

On Sunday evening, I open VS Code Insiders and run a single command from a custom VS Code extension (I had Copilot help me build) to create my new Week of ... file from a template. Then I do something deliberately manual, I open my calendar and manually type in each meeting in the Weekly Notes file and block out focus time on the calendar. This takes about ten minutes and feels like a warm-up before a run. By the time I’m done, my brain holds the week’s shape—meetings clustered here, deep work carved out there, the main threads I’ve chosen to move forward sitting at the top.

Manual priming helps me create the narrative arc. Automation could populate my schedule faster, but I wouldn’t remember it. The friction is the feature.

During this priming process I’ll often use Copilot in VS Code to help me remember things I’ve been working on recently and try to find interconnections and opportunities to integrate work across teams. The ideas from this often feed back into my calendar as new meetings or checkpoints.

Everything throughout the week now flows from this single source of truth.

Folder	Purpose
Weekly Notes	Planning, goals, schedule, and backlinks to meetings
Meeting Notes	Rolling notes with newest sections at top
Daily Projects	Day-level staging: scratch pads, transcripts, context dumps
Transcripts	Raw meeting transcripts before summarization
Executive Summaries	Distilled updates for leadership
Projects	Multi-week initiatives with numbered working notes
Snippets	Weekly accomplishments: Ships, Risks, Collaborations, Shoutouts
Archive	Cold storage after things have aged out of usefulness for the current year

The structure matters less than the organizing principles that make it fast. For example with Meeting Notes I keep the most recent content at the top. When I open a Meeting Notes file, or when Copilot does, the first screen shows what matters most right now. Historical context is there when I need it, but I don’t have to scroll past it to remember what happened yesterday.

Since I’m working in VS Code I can give it custom Copilot instructions and you can see my current iteration here.

I use wikilinks instead of duplicating content. When I need to reference a decision or a meeting, I link to its source rather than restating it. The trail of breadcrumbs matters because both future-me and my AI agents follow the same path. If I can’t trace how I arrived at a conclusion, I probably don’t understand it well enough yet.

Numbered prefixes on files encode creation order within a day or project folder. 01 focus.md, 02 pairing notes.md, 03 random idea.md. This sounds fussy, but it makes keyboard-driven scanning instant. I know 01 was my starting point and 05 was where I landed after four pivots. The numbers tell a story even before I open the files.

Why Markdown in VS Code?

I’ve tried plenty of alternatives over the past two decades—Notion, Obsidian, Apple Notes, and yes, GitHub Projects for task tracking. Each has merits, but they all introduced friction that slowed me down because of how my mental and physical muscles work.

Web-based tools lock me into connectivity requirements and proprietary formats that concern me for long-term retention. GitHub Projects is powerful for cross-team visibility, but the overhead of maintaining another system rarely pays off when I already have my brain folder working well.

I ask myself one question when evaluating any tool or process: does this shorten my loop from idea to artifact to decision? If I can’t answer yes, I’m probably adding decoration.

GitHub Flavored Markdown in VS Code wins for me because it’s fast, diffable (easy to compare changes between versions), searchable, and works offline. AI agents can read and write files directly, which lets me delegate grunt work without switching contexts. The format will outlive any single app, and if I ever need to migrate, the files are just text.

I do use a folder syncing tool to keep my brain accessible across my devices so I can read and write markdown files from my iPhone as needed, but my primary user interface is VS Code Insiders on a Macbook Pro M1.

Optimizing Execution

Every day I create anywhere from one to dozens of Daily Project files to act as scratchpads for each idea I’m pursuing. After creating a file in Daily Projects (also using the custom VS Code extension I have in my brain folder) I almost always turn to Copilot as a pair partner to help me start collecting artifacts, sifting through details, and formulating ideas or final outputs.

I have Copilot choose the model by setting it to Auto mode (h/t Brittany Ellich) and it works surprisingly well.

When I’m working across multiple repositories—which is most of the time these days—I use a CLI tool I built to spin up VS Code Workspaces with git worktrees. I tell Copilot “start a workspace with these projects,” and it uses the cli to find the projects on disk, creates worktrees for each, and drops them all into a single VS Code Workspace. The friction of juggling branches across repos disappears, and Copilot can now search or change code across all of them in one session.

GitHub remains my system of record for anything collaborative: Issues, Pull Requests, Discussions, and a little bit of Projects when the coordination benefit outweights the maintenance cost.

Walk → Think → Write

Some of my best thinking happens away from the keyboard and the distractions email and chat. When I’m stuck on a design problem or trying to work out the narrative arc of a post, I’ll often grab my phone and go for a walk.

I record a voice memo—just talking through the problem out loud, no script, no editing. Sometimes it’s coherent, sometimes it’s a mess. Doesn’t matter. Most of the source of this post was created from the transcripts of walks I took along the Truckee River this week while visiting Reno Nevada.

Closing the Loop

Last year I didn’t capture all of these artifacts. Meetings would happen, decisions would get made, and a week later I’d be piecing together what we agreed to from memory, Issues, and stray Slack messages. Reflection was exhausting because I had no artifacts to base my reflections on.

Now I capture everything. After every meeting, I run a script that grabs the transcript, generates an executive summary, and updates my Meeting Notes/<person>.md file with a new date section at the top—wikilinks to the transcript and summary, plus a few bullets on decisions and follow-ups. The whole thing takes maybe thirty seconds.

When I sit down with Copilot to write my weekly snippets or prep for a retro, I’m not reconstructing memory. I’m reviewing artifacts I created in real time: closed PRs, meeting summaries, Daily Projects files. Copilot can pull from all of it because it’s already written down and organized. The collaborative reflection part—“what themes do you see across these meetings?” or “what shipped that moved our OKRs forward?”—is easy now because the raw material is sitting there waiting.

Each week I write snippets. What shipped, what’s risky, what’s blocked, new ideas, who I collaborated with, who deserves a shoutout. Later when I need promotion materials or I’m prepping for a semester retro, I have months of weekly artifacts to pull from instead of a blank page and a vague sense of “I think I did some stuff.”

The reason this works for me is that each piece serves multiple purposes. Meeting Notes, Issues, and Pull Requests feed snippets, snippets feed retros, retros shape next semester’s planning. I’m building on what’s already there instead of starting from scratch every time.

What’s Next

Next up is working through current friction points including:

Workspace Manager (VS Code Workspaces + git worktrees) works well for multi-repo projects, but running the same app in multiple workspaces creates port conflicts (dev servers, databases, other dependencies). I’m evaluating devcontainers and other isolation strategies to fix this.
In-person meetings are clunky to turn into usable transcripts. I record on my phone and run it through MacWhisper, but labeling speakers and threading context is still too manual. I haven’t found a flow that feels as smooth as labeled transcripts in Zoom or Teams.
I’m using Microsoft Teams and M365 more and more for work and feeling some pain. I imagine that will continue for a bit (new UX, new defaults, new bugs), but it also opens doors: maybe I can stop manually starting transcripts, maybe I can wire Teams events straight into my meeting-notes workflow. I’ll report back once I stub my toe a few times 😅

I love learning about how other people work so please send me your favorite tools, processes, or mental models! Happy Holidays 🎊

Building Career Security in an Uncertain World

2025-10-23T00:00:00Z

Earlier today I saw a friend post about layoffs. Someone they were collaborating with on a project had just been let go. “I will be anxiously distracted for the next few days,” they wrote, “trying to yet again pivot a collaboration I was planning on.”

The conversation that followed touched on questions many of us are wrestling with right now. How can critical engineering positions get cut when security issues are mounting? Why plan a project if the people who can execute it aren’t considered essential? And underneath those tactical questions sat a deeper, more personal one: Am I next?

I wanted to respond with empathy, but also with something useful, so I shared a few thoughts in the moment and then started working on this post.

Their frustration is completely valid—the randomness of layoffs makes planning feel futile. But I’ve learned something over nearly 14 years at GitHub and 28 years in tech that might help. Job security doesn’t exist. It never did. Companies make decisions that don’t make business sense to those on the ground. Layoffs happen even when the work is critical. The promise of a stable position is always fragile.

But career security? That’s real to a degree. And it’s built through deliberate practice, not by holding tight to any single job.

Feedback I received on this post: when it feels like things are going sideways make sure to “take 5min to check-in with yourself and name what are you feeling in the moment instead of catastrophizing in your head. It gives a more clear perspective of what steps you have access to do next.”

The Uncomfortable Truth

I’ve watched this cycle play out more times than I can count. Earlier this year, we lost three teammates on my own team at GitHub to layoffs. Amazing humans doing important work. It didn’t make sense then and it doesn’t make sense now. The logic of layoffs is rarely visible from the inside.

The tech industry swings wildly between hiring binges and brutal layoffs. Companies staff up when they want to impress investors with growth metrics, then slash headcount when those same investors demand profitability. It’s a cycle that serves shareholders, not the people doing the actual work. And navigating this gets harder, not easier, as you advance in your career—the financial stakes rise as you take on mortgages, family responsibilities, and all the obligations that come with building a life.

So how do I deal with this reality? I accept it, and I prepare.

Nothing is Guaranteed, So Always Be Preparing

Here’s what I told my friend, and what I try to practice myself: Nothing is guaranteed, so it’s important for each of us to consider our strengths and weaknesses and to prepare.

That preparation isn’t about living in fear. It’s about building the kind of career resilience that creates opportunities even when your current job disappears. And critically, it’s about being careful not to tie your identity to the company’s decisions. Your mental health depends on recognizing that business decisions you can’t control don’t define your worth. You can control your skills, your relationships, and your preparation—so that’s where to focus your energy.

Build Relationships Inside and Outside Your Company

The most important preparation isn’t technical—it’s relational. I wouldn’t be at GitHub if I hadn’t met Steve Smith and John Nunemaker at a small meetup at Notre Dame back in 2007. We kept in touch, built a friendship over three years, and in 2010 they offered me a job at Ordered List. A year later, when GitHub acquired Ordered List, that entire relationship network came with me.

One conversation at one meetup created a cascade of opportunities that shaped my entire career. But here’s the thing—I wasn’t networking in the transactional sense. I was genuinely interested in what they were building. I showed up consistently. I contributed where I could. The relationship was real long before it became professionally valuable.

Network with intention, but with authenticity. Get off your butt and go to meetups even when you don’t feel like it. Reach out to people whose work you admire. Contribute to projects and communities you care about. These relationships compound over time in ways you can’t predict.

Interview Every 1-4 Years, Even When You’re Happy

This one is uncomfortable to hear, but it’s critical. Go on interviews even when you don’t need a job.

I’ve done this every 3-4 years since joining GitHub. Not necessarily because I was looking to leave, but because interview skills atrophy without use. I’ve never been a naturally strong interviewer, so it’s been important for me to exercise that muscle and get over my fears and insecurities.

Here’s the tactical part most people won’t tell you. Your first few interviews when you start interviewing again should never be with the company you want to work for. Those are practice. Those are to shake the rust off. Learn from those early interviews on companies that are further down your list.

I’ve failed a lot of interviews. I failed at Google. I failed at startups where the combined experience of the entire team was less than mine. I failed at companies where I was good friends with people on the team I was interviewing for, people who knew my work. Each failure taught me something. Interviewing is a skill that requires repetition, not cramming.

And here’s the irony—those periodic check-ins with the market actually made me appreciate GitHub more. Seeing what else was out there helped me recognize what I had. That quick check to see if the grass was greener helped me come back each time and appreciate where I was even more.

Feedback I received on this post: “One thing that can accelerate this learning is paying for professional mock interviews. It’s humbling how quickly an experienced interviewer can spot your blind spots. That external feedback is worth far more than another week of solo practice.”

Do As Much of Your Work in the Open as Possible

If you can’t show your work, you can’t prove your work. This has been one of my core practices for almost two decades—make things public whenever possible.

Every blog post I wrote about Hubot in 2011 is still online, still demonstrating my technical thinking. The Speaker Deck project I helped build is still in my portfolio. The conference talks I gave in Italy and elsewhere are still searchable. All of this public work has opened doors I didn’t even know existed.

Your portfolio is your interview that never stops running. When I joined Ordered List, and later when GitHub acquired us, people didn’t need to guess what I could do. They could see my code, read my explanations, watch my talks. The friction of hiring me was lower because the evidence was public.

Here’s the ladder I’ve seen work:

Foundation: Code in public repositories. Contribute to open source. Even small contributions count.
Next level: Start a blog. Document what you’re learning. It doesn’t have to be groundbreaking—tutorials and how-tos are incredibly valuable.
Level up: Build a cadence of writing and sharing. Consistency matters more than perfection.
If you’re brave or even if you’re not: Try public speaking. Start at local meetups. Work up to conference talks.
Throughout all of this: Build genuine relationships. The network you create while doing public work is as valuable as the work itself.

The content you create today can help you get interviews years from now. I know because it’s happened to me.

Document Everything

This is both practical and strategic. Document your work, your decisions, your contributions. Keep a record of your accomplishments, the problems you solved, the impact you had.

Why? Because when you do need to interview, you’ll have concrete examples ready. Because when performance review time comes, you won’t be trying to remember what you did six months ago. Because if your role gets eliminated, you’ll have a clear narrative of your value to share with the next employer.

I keep notes on everything. Conversations, technical decisions, projects shipped. It’s my external memory and my career insurance policy.

Analyze Yourself

I learned the SWOT analysis framework in college and I’ve been using it ever since. Every few months, I sit down with pen and paper and brutally assess my Strengths, Weaknesses, Opportunities, and Threats.

There are great alternatives to SWOT including SOAR (Strengths, Opportunities, Aspirations, Results), Gap Analysis, and Personal Balanced Scorecard.

The key is brutal honesty. You’re not sharing this with anyone, so don’t sugar-coat the weaknesses. Don’t undersell the strengths. Look for opportunities that address multiple weaknesses while building on strengths. Identify threats that could turn strengths into weaknesses.

After doing this a few times, patterns emerge. You start to see where you’re vulnerable, where you need to grow, where the market is moving. This isn’t abstract self-help—it’s strategic career planning.

The Long Game

One of the most accelerating forces in my career has been mentorship, both receiving it and eventually giving it.

When I started at Ordered List, I paired with Brandon Keepers three or four days a week. He had years of programming experience and taught me how to write maintainable code, how to think through problems, how to build elegant solutions. That intensive pairing compressed years of learning into months.

John mentored me on career growth and personal development through weekly meetings. We talked about goals, about challenges, about life beyond code. That external perspective helped me see patterns I couldn’t see myself.

Mentorship accelerates your growth, gives you perspective from someone who’s seen more careers (including failures), holds you accountable, and expands your network. A good mentor warns you about pitfalls before you hit them.

Finding mentors takes patience. The relationship with Steve and John that eventually led to my job started years before they hired me. You can’t sprint relationship building. But you can be intentional about seeking out people you respect and learning from them.

And eventually, you pay it forward. Mentoring others isn’t just good karma—it deepens your own understanding and expands your network in new directions.

The Reality of Failure

I need to say this clearly. Building career security through these practices doesn’t mean you won’t fail. You will. I have.

I’ve failed interviews at companies I desperately wanted to join. I’ve given talks that landed flat. I’ve written a lot of code that got rejected. I’ve built relationships that didn’t lead anywhere personally or professionally.

But each failure was data. Each one taught me something. The key is to not let failure discourage you from continuing to build these muscles.

Interview prep isn’t something most people can do in a few days or even weeks. It takes repetition to build the skills and confidence to pass technical interviews. Portfolio building isn’t a weekend project. Public speaking doesn’t get comfortable after one talk.

This is all a long game. Start now, not when you need it.

What This Looks Like in Practice

Let me be concrete about what “always be preparing” means:

This month:

Attend one meetup or community event
Write one blog post or tutorial (even a short one)
Update your resume/portfolio with recent work
Reach out to one person you admire

This quarter:

Do a SWOT analysis on yourself
Contribute to one open source project
Have coffee with someone outside your immediate team
Document your major accomplishments

This year:

Go on at least 2-3 practice interviews
Invest in your interview skills (prep courses, mock interviews, or practice platforms)
Give one talk (even at a small meetup)
Build one public project
Find or strengthen one mentoring relationship

None of these are radical. None require quitting your job or working 80-hour weeks. But together, consistently practiced, they build the foundation of career security.

And here’s permission you might need. If you’re overwhelmed, there’s nothing wrong with coasting short-term. Take care of yourself first. This is a marathon, not a sprint. Sometimes the smartest career move is to preserve your mental health and energy for when you really need it.

The Paradox of Preparation

Here’s what I’ve learned. The best time to build job security is when you don’t need it.

When you’re employed and comfortable, you can be selective about opportunities. You can practice interviewing without desperation. You can build relationships without ulterior motives. You can create public work without pressure.

When layoffs come (and they will), that preparation is what saves you. Not because you have a backup plan, but because you’ve built something more valuable than job security—you’ve built career security.

The relationships are already there. The portfolio already exists. The interview muscles are warm. The network already knows your work. You’re not starting from zero.

Back to My Friend

I can’t promise my friend that they won’t be affected by the next round of layoffs. I can’t make the next collaboration work out. I can’t make any of this fair or sensible.

But I can tell them what I believe. Their value isn’t determined by any single company’s decision. Their career security comes from the skills they build, the relationships they nurture, the work they share publicly, and the preparation they do now.

Nothing is guaranteed. And that’s exactly why we prepare.

Designing Collaborations, Not Just Automations

2025-09-01T00:00:00Z

In my last post, The Uncertain Future of Coding Careers (and Why I’m Still Hopeful), I wrote about something I’ve always found exciting as a developer: working myself out of a job so I can work myself into the next one. I don’t come from a CS background and my programming journey has always been focused on solving problems that matter to me, and that often means automating away the tedious parts of my work.

The pattern has been consistent: every time I automate away repetitive work, new challenges appear upstream. And the upstream work is often more interesting, more impactful, and more human.

This sequel is about how I’m seeing that play out in real time. It’s a story about reflection, the hidden purpose of seemingly tedious tasks, and the surprising power of designing collaborations, not just automations.

When Automation Delays Understanding

For almost a year, I tried every possible way to automate my weekly writeup to leadership (at GitHub we refer to these as snippets): pasting prompts into Copilot, building agentic workflows, trying out yet-to-be-released tools my coworkers are building, you name it I tried it. And every time I ran into the same problems:

The output was terrible. It was verbose, inconsistent, or just plain wrong. I spent almost as much time fixing the results as I would have spent writing them myself.

But more importantly, I wasn’t learning anything. Snippets became a chore. I wasn’t reflecting, I wasn’t seeing patterns in my work, I wasn’t building understanding of what mattered. It was just another TPS report—faster busywork, not better outcomes.

Here’s what took me too long to realize: writing snippets wasn’t just about informing leadership. The act of reflection—forcing myself to review the week, identify what worked, process what I learned—was building understanding in my own mind. When I automated that away, I lost something valuable: the cognitive work that made me better at my job.

This applies beyond snippets. Code reviews aren’t just about catching bugs—they’re about building shared understanding of the codebase. Documentation isn’t just about recording information—it’s about clarifying your own thinking. Even debugging isn’t just about fixing problems—it’s about building mental models of how systems work.

Not all tasks exist to produce an output. Some exist to build understanding. Automating those defeats the whole purpose.

The Breakthrough: Preserve Learning, Reduce Grunt Work

Two things shifted my approach:

A self-reflection habit. In my weekly “how I work” review, I noticed my best outcomes always came from collaboration—pairing with teammates, debating with peers, even bouncing ideas off Copilot. Collaboration, human or AI, was where the wins came from.
Discovering VS Code Chat Modes. Chat Modes gave me a way to design a lightweight, context-specific collaborator in seconds. Instead of trying to build a complex multi-step agentic workflow, I could create an AI partner with a few paragraphs of instructions.

The key question became: “What am I supposed to learn from doing this?” If the answer was “nothing,” automate away. If the answer was meaningful, design a collaboration that preserves the learning while reducing the grunt work.

The result was my Snippets Interviewer Chat Mode. Instead of only collecting context and generating near final output in one go, it asks me questions, checks sources, and lets me edit and interject. Most importantly, it helps me think about what I did that week by turning it into a conversation.

When I automated the task I regained 30-45 minutes of time but the meaning disappeared. When I designed a collaboration, both efficiency and understanding remained.

Why This Matters Beyond Individual Tasks

The future of coding careers isn’t about doing tasks faster—it’s about designing better collaborations that preserve what humans need while eliminating what we don’t.

I’ve been seeing this pattern emerge:

Automation replaces execution. Once we know exactly what needs doing, machines can do it faster and cheaper.
Collaboration enhances exploration and understanding. When problems are ambiguous, when we need to learn, when we don’t even know what questions to ask yet, collaboration is where value is created.

This insight is a fundamental career principle. The more you move upstream into framing, guiding, and curating—the work that builds understanding—the less replaceable you become.

And it scales beyond individual work. I’ve started creating Chat Modes for my team, like this one that helps us upgrade project documentation. It turns a solo documentation task into a collaborative process where the improved docs help new teammates onboard faster and old teammates reload context with less effort. As I wrote in Context Rules Everything Around Me, context creates the foundation for more effective AI collaboration.

What AI Still Can’t Do

In conversations with friends (and with ChatGPT itself, ironically), I keep coming back to a nagging question: can we ever teach machines to truly explore? To intuit? To decide what’s worth understanding?

Right now, the answer is no. LLMs are incredible at predicting what comes next, but not at deciding what ought to come next. They don’t have goals. They don’t want anything. They don’t care.

That means exploration, venturing into the unknown, choosing what’s worth solving, building understanding through reflection—that’s still ours. And that’s good news, because exploration and understanding are the most rewarding parts of the job.

My snippets Chat Mode is a perfect example. The AI can search, summarize, and draft. But only I can decide which risks matter, which collaborations deserve a shoutout, which themes are worth elevating. That’s exploration. That’s understanding. That’s me.

Climbing the Abstraction Ladder

I’m thinking about this as an abstraction ladder where each rung preserves human understanding while eliminating mechanical work:

A generation ago, debugging memory management was a big part of coding.
Then we moved up to writing applications without worrying about memory.
Now we’re moving up again: coding with AI pair programmers that handle boilerplate, syntax, even architecture patterns.

If your career is tied to a specific rung, the ladder can feel scary. But if your career is tied to climbing the ladder itself—to curiosity, adaptability, and upstream thinking—you’re better positioned for whatever comes next.

The skill that endures isn’t “knowing X language” or “mastering Y framework.” It’s: designing collaborations that preserve understanding while eliminating busywork. Every new collaboration we design creates value that’s harder to automate away because it amplifies human insight rather than replacing it.

New Metrics of Accomplishment

Something unexpected happened when I redesigned snippets around collaboration: the purpose of snippets changed.

Before, snippets were proof of activity. A list of what I did.
Now, snippets are a reflection. A mirror of what mattered, a record of collaboration, and a chance to give credit.

By shifting from automation to collaboration, I didn’t just make snippets faster—I made them more meaningful. I came away not with a report, but with insights, gratitude, and perspective.

I think this previews what’s ahead for all of us. As AI accelerates execution, the real measure of accomplishment won’t be “how much we did” but “how well we understood, framed, collaborated, and explored.”

So What’s Next?

If automation keeps marching forward, and it will, what kind of work should we focus on?

Here’s my short list—all work that builds understanding:

Framing problems: defining what to solve is harder than solving it.
Exploring ambiguity: the messy, undefined spaces where understanding emerges.
Curating judgment: knowing which answers are right, safe, ethical, or impactful.
Designing collaborations: building processes (with humans and AIs) that preserve learning while reducing grunt work.
Recognizing others: amplifying collaboration, giving credit, building trust.

If you’re looking for a career compass in uncertain times, ask yourself: “What am I supposed to learn from this work?” Then design collaborations that preserve that learning.

Conclusion

When I look back on my first experiments with automating snippets, I see the broader automation trap. I thought the goal was to make the task disappear. But when the task disappeared, so did the meaning—and the understanding it was supposed to build.

The breakthrough came from reframing the question. Not “How do I automate this?” but “How do I design a collaboration that preserves what I need to learn while eliminating what I don’t?”

That’s the bigger lesson for coding careers in the age of AI. The robots aren’t replacing us anytime soon. They’ll get smarter, they’ll remix our work, they’ll even surprise us. But the frontier of exploration, understanding, and meaningful collaboration is still ours.

If you want to thrive in that future, don’t just automate—collaborate. Design partnerships that make you smarter, more reflective, and more human, not just faster.

Context Rules Everything Around Me

2025-07-16T00:00:00Z

I was drowning in meetings, losing track of decisions, and manually typing notes I never revisited. Then I found a better way—capture once, reuse everywhere with AI. In this post, I’ll show how I record and transcribe meetings, feed transcripts to large language models, and generate immediate action lists, summaries, and architecture drafts. It transformed my workflow from frantic note-taking to an effortless meeting superpower.

TL;DR

I record nearly every meeting call (or use my phone’s Voice Memos for in-person).
I use Zoom’s built-in transcript (or convert a recording to a transcript using a tool like MacWhisper).
I run the transcript through an LLM (like GitHub Copilot, ChatGPT, or GoogleGemini) with a prompt to produce executive summaries, decision logs, or whatever artifacts I need.
In my experience, meeting clarity shot up, and my weekly status prep time fell by about 80%.
See below for the minimal reproducible “transcript→prompt→artifact” stack you can try this weekend.

Too Many Meetings, Too Little Clarity

Late last year, I moved into a principal engineer role at GitHub, and my meeting load tripled almost overnight. I was juggling dozens of syncs, architecture reviews, async updates, and 1:1s every week. I’d leave a call with a few scribbled bullet points, but promptly forget half of the decisions by the next day. The bigger my scope became, the less my scattered note-taking kept me afloat.

I realized that if I wanted to stay on top of critical decisions—let alone communicate them to peers and leadership—I needed a better system. Enter full transcripts. Once I started capturing entire conversations verbatim, it finally “clicked” that I could feed this raw context into AI to produce highlights and next steps. The difference was night and day.

Why Transcripts? The Breakthrough

I initially tried built-in “auto-summaries” from meeting software, but they were half-baked or missed nuance because the prompts sucked and they lacked good speaker attributions. Then I discovered the Zoom accessibility transcript option on calls: a text feed with speaker labels that I could save manually. Suddenly, I had an accurate record of “who said what,” ready to pipe into an LLM. This overcame the usual “notes are incomplete” feeling and let me be fully present in meetings rather than trying to type everything I heard.

For in-person offsites, I used my phone’s Voice Memos to capture audio. I’d import these recordings into the MacWhisper app, which automatically transcribed and even attempted speaker detection. Although I’d sometimes need to tag speakers manually, the payoff was huge: every voice or contribution or subtle nuance was preserved.

With these transcripts, a quick AI pass yielded exactly the details I needed:

A bullet-pointed to-do list with owners.
A short summary for my manager’s weekly update.
A “what we decided” snippet for reference in a follow-up doc.

Before transcripts, I’d scramble to reconstruct these details by memory or rummage through half-finished notes. Now it’s one prompt away.

Proof: Fewer “Did We Decide That?” Moments

After a few weeks of using transcripts in all my calls, I noticed:

I was participating in meetings instead of just taking notes.
My personal “action item capture rate” soared—I rarely missed tasks assigned in a meeting.
I got ~4x more context out of the same meeting time because I could always re-check the transcript.
My writing speed for proposals and status updates skyrocketed, saving me up to 80% of the typical prep time.

Best of all, the entire team benefited. Fewer “Wait, I thought we agreed on something else” rewinds. Less chat message churn. I even started copying my executive summaries to meeting participants within seconds of a call being done, which drastically reduced random pings for clarifications.

One anecdote stands out: during a three day offsite, I recorded 24 hours of brainstorming with Voice Memos, then fed them into a speech-to-text model. I posted a daily summary to keep everyone aligned. After the offsite, I produced a single, cohesive doc capturing all decisions, complete with quotes and proposals. That doc ended up steering part of our next quarter’s roadmap—something that wouldn’t have been possible if we’d relied on my scribbles alone.

Some testimonials from folks who have adopted my workflows and prompts:

This is fantastic @jonmagic - the quality of the executive summary is suprisingly high! Going to use the heck out of this 🙇🏼

This is soooooo good. I’m going to have to play with this. I’ve also started to move much faster and by the end of the week, I will reflect on discussions I’ve had and not remember who they were with “Where did I hear this? Didn’t they say…?” Thank you @jonmagic.

h/t to @jonmagic, I’ve fully bought into using transcripts and AI summaries for meetings. While they’re not perfect and can hallucinate, they let me stay present instead of taking notes.

The Minimal Reproducible Stack

Below is the core technology and workflow I suggest trying. It’s easy to set up on a weekend, and you’ll see immediate results.

Capture
- Use Zoom or Teams recordings, making sure you enable transcripts (see gif above).
- For in-person: use your phone’s Voice Memos or any handheld recorder.
Get into the habit of hitting that Transcript or Record button as soon as you join a meeting and for Zoom use an AppleScript like this to ensure the Save transcript button is clicked frequently so that you don’t lose any of the transcript before the call ends.
Transcribe
- Skip this step if you were able to get a transcript during the capture phase.
- For voice recordings Voice Memos is great and will generate a transcription for you if the recording isn’t too long.
- If you prefer a desktop app, tools like MacWhisper.cpp add speaker detection automatically.
Prompt
- Feed your transcript into an LLM along with the processing instructions (aka a prompt). GitHub Copilot is an excellent LLM and free (or inexpensive depending on your volume).
- That prompt might produce an “executive summary” or an “action item list,” depending on which prompt you decide to use. See my repository of prompts for a few options to get you started.
Outputs
- Store the final summary as text or Markdown (version-control it if you want an audit trail).
- Share or link it to relevant tasks, tickets, or Slack for easy reference.

I use these steps multiple times a day from meetings to capturing ideas while taking short walks. I recorded all of the context needed for an architectural decision record the other day and from there it was just a short conversation with an LLM to put it into the ADR format.

Advanced Moves

Heads-up: The tools below live in my jonmagic/scripts repo. They assume you’re comfortable cloning a repository, installing and configuring the gh cli, installing and configuring the llm cli, and creating shell aliases. They’re optional, but once they click, they feel like cheating.

`fetch-github-conversation` — one-command context vacuum

Pull an entire Issue, Pull Request, or Discussion thread (comments + diffs) to STDOUT, ready for your favorite prompt.

alias fgc="$HOME/scripts/fetch-github-conversation"

fgc https://github.com/org/repo/issues/123

Why it matters – Grabbing the full conversation (including all comments) lets the LLM reason with complete history, producing tighter summaries and reducing “what happened earlier?” churn.

`prepare-commit` — AI-drafted commit messages

An interactive script for generating a git commit commit of your staged changes using the semantic commit message guidelines.

alias commit='~/code/jonmagic/scripts/bin/prepare-commit --commit-message-prompt-path ~/code/jonmagic/prompts/generate/commit-message.md'

commit

Why it matters – You get crisp, context-rich commit messages without the mental tax of writing them from scratch—perfect when you’re shipping ten tiny PRs a day.

`github-conversations-research-agent` — deep-dive, cite-everything analysis

Full tutorial coming soon but in the meantime if you’re curious to see an advanced agent and semantic RAG setup at work to thoroughly answer questions that require multi-turn research check out this gist.

Always check local rules and company policy before recording. In some regions, it’s mandatory to disclose or request consent from all participants. Data security is crucial: if transcripts contain sensitive or personal information, encrypt them at rest and redact as needed before sending them to cloud-based LLMs. In short: be transparent, and protect confidentiality.

Accessibility & Inclusivity

This isn’t just about saving you time. it’s about ensuring every voice is amplified. Transcripts help teammates who are Deaf, communicate differently, or absorb information best via text. They also bridge gaps across remote, asynchronous, and time‑zone‑spread teams. making sure no one is left out.

C.R.E.A.M. — Context Rules Everything Around Me

In the '90s, Wu‑Tang Clan rapped Cash Rules Everything Around Me. At early GitHub, C.R.E.A.M. was a north star for open financial ops. In 2024, my own C.R.E.A.M. stands for: Context Rules Everything Around Me.

Where do you go from here? Try capturing one meeting this week and feeding the transcript to your favorite LLM. If you’re already doing that, level up with advanced prompts or a record and transcribe process at an offsite. Let me know how it goes.

Feedback

I would love to hear from you: discussions/8

Thank you for your time 🙏

Farewell RailsConf and Thank You For Everything

2025-07-07T23:59:59Z

2006, Chicago. Nearly everyone at the first RailsConf tapped away on a MacBook, except about fifty rebels. My friend Christian Metts, who had introduced me to Rails, and I printed Certificates of Nonconformity, forged Bill Gates’ and Linus Torvalds’ signatures, and handed them to the non-MacBook crowd while Christian snapped photos of each proud hold-out, including the elusive why the lucky stiff.

That playful moment, the community, and the shared curiosity, set the tone for everything that followed.

Finding Rails & Finding My People

Like many, using Rails was the forcing function for me to learn Ruby (with help from why’s poignant guide to Ruby 🙏), and that first conference pushed me deeper. Soon after, I drove to a Ruby meetup at Notre Dame and met John Nunemaker and Steve Smith. One afternoon over beers at Fiddler’s Hearth in South Bend, they vented about SlideShare’s terrible user experience. I opened my terminal, installed ImageMagick, and hacked together a PDF-to-image converter on the spot. That bar-top prototype grew into Speaker Deck and my first RubyGem, Grim.

Building Businesses on Rails

In December 2010 I became OrderedList’s first full-time developer, joining Steve, John, and later Brandon Keepers and Matt Graham. We iterated on their first product Harmony, launched Speaker Deck to the public, and shipped Gaug.es, a Rails-based analytics tool born from our dislike of Google Analytics. Consulting gigs on products like Words With Friends paid the bills.

Through meetups and conferences our team met the GitHub co-founders and early employees such as Tim Clem and Zach Holman. In the fall of 2011 GitHub invited us to join as their first acqui-hire.

A GitHub Career

After our acquihire in late 2011, I worked my way through nearly every department at GitHub building our support software (a Rails app called Halp), integrating our business systems with the GitHub monolith, building tools for our customers to migrate between GitHub on-prem instances and our hosted instance, shipping 2fa enforcement features for our business customers, and finally landing in the Security department where I’ve been for nearly 9 years now.

Brandon, John, and I were among GitHub’s earliest users, with IDs #173, #235, and #623.

In Security I’ve built multiple Rails applications but only one of them is still in heavy use. Funny enough it’s a stream processing application where the Rails MVC has been swapped out with Consumer, Enrichment, and Detection modules to handle the majority of our automated abuse detection and remediation flows processing billions of events per day.

I still work on the GitHub Rails monolith from time to time, but new Rails apps are rare for me now, and I miss it. There’s nothing like spinning up a Rails app from scratch and going from zero to usable in minutes. Rails made it simple to focus on the business problem and get something up and running quickly with the tradeoff that scaling later may come with some headaches.

The Last RailsConf

This week in Philadelphia they are holding the last RailsConf, concluding nearly 20 years of tradition. Ruby Central is shifting focus to RubyConf and stewardship of RubyGems and Bundler, while The Rails Foundation steps into Rails stewardship via Rails World, which sold out Toronto in seconds.

DHH, creator of Rails, shares the sentiment:

“Few numbers exemplified the early growth… we bootstrapped something from nothing, turned it into an epoch‑defining event… RailsConf 2025 will be the last RailsConf… I raise my glass to the final RailsConf.”

While I haven’t been deeply involved in the Rails community recently, as I prepared this post I learned how Rails World and RubyConf are shaping Rails’ future, and I’m hopeful for the aspiring or seasoned software developer that finds Rails and it changes their life like it did mine.

A Thankful Reflection

RailsConf gave me identity, community, and confidence. But more than anything, it connected me with incredible people, from the early Rails pioneers I met at conferences to the teammates who became lifelong friends, from mentors who shaped my thinking to fellow developers who challenged me to grow. The names and faces have accumulated over nearly two decades, each person adding something meaningful to my journey. The Rails community has always understood that great software comes from great people working together.

So this last RailsConf isn’t a swan song, it’s a celebration. My professional software development journey started here, and I’m deeply grateful. Here’s to the Rails way: convention over configuration, developer productivity, and a culture of collaboration. Thank you, RailsConf, and thank you, Rails community.

One More Thing

I haven’t created a Rails app recently but I still write a lot of Ruby and share most of it as open source including my port of pocketflow to Ruby, my scripts project for AI workflows, and a few of my other projects.

Feedback

Feedback is welcome: discussions/7

Thank you for your time 🙏

Adding client-side semantic search to jonmagic.com

2025-07-03T00:00:00Z

I recently rebuilt jonmagic.com from the ground up with help from GitHub Copilot, transforming it from a boring about page into a real blog and migrating over 100 posts from my old blog. After adding this much content, I wanted a way to make it searchable, but using eleventy on GitHub Pages meant there was no backend to rely on.

Most of my projects these days involve building AI-powered features, so I started to wonder if it was possible to add semantic search that runs entirely in the browser, even on a static site? Turns out it is and with a little help from ChatGPT and Copilot I had it up and running in an hour.

Sorry, your browser doesn't support embedded videos.

Video Demo: Semantic search returning posts that match concepts, not just keywords.

The entire semantic search (including the model) runs on your device, inside the browser, using precomputed post embeddings. No server required!

Try it yourself: Search jonmagic.com

Later I found out about https://pagefind.app/ and did briefly consider it but afaict it doesn’t support semantic search and my site only has a little over 100 blog posts so I’m very happy with the solution I landed on.

How It Works

1. Embedding posts during build.

At build time, I use @xenova/transformers to generate a vector embedding for each post. This happens in the build script:

// src/_build/indexVectors.js (excerpt)
const tensor = await extractor([textToEmbed], {
  pooling: 'mean',
  normalize: true
});
updated[full] = {
  vector: Array.from(tensor.data),
  metadata: { ... }
};

These go into a static vectors.json file.

2. Embedding queries in the browser.

On the search page, as you type, your query text is embedded client-side using the same model (MiniLM-L6-v2). That means no server round-trips, and your queries are never sent anywhere.

// src/js/embedQuery.js (excerpt)
const { pipeline } = await import('https://cdn.jsdelivr.net/npm/@xenova/transformers@2.17.2/dist/transformers.min.js');
const extractor = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');

export async function embedQuery(query) {
  const tensor = await extractor([query.trim()], { pooling: 'mean', normalize: true });
  return Array.from(tensor.data);
}

3. Finding the best matches.

The browser calculates cosine similarity between your query embedding and every post embedding. The top matches are shown, sorted by score.

// src/js/search.js (excerpt)
function cosineSim(a, b) {
  let dot = 0, normA = 0, normB = 0;
  for (let i = 0; i < a.length; i++) {
    dot += a[i] * b[i];
    normA += a[i] * a[i];
    normB += b[i] * b[i];
  }
  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
}

export function topK(queryVec, vectorData, K = 10) {
  return Object.entries(vectorData)
    .map(([filePath, item]) => ({
      score: cosineSim(queryVec, item.vector),
      metadata: item.metadata
    }))
    .sort((a, b) => b.score - a.score)
    .slice(0, K);
}

What You Can Search For

Topics: e.g., "project management", "learning new skills"
Questions: e.g., "advice for new developers"
Fuzzy phrases: e.g., "why did I move to git?" or "being acquired at work"

You’re not limited to exact words, vector search will match related posts.

What’s Next?

Next I’d like to see if client-side Retrieval Augmented Generation (RAG) is possible. That is, not only find relevant posts, but also pass their text into a client-side LLM that can summarize or answer questions about my own blog, entirely on your device.

If you’re interested in following along, subscribe to the feed or check out the search page.

Feedback

Feedback is welcome: discussions/6

Thank you for your time 🙏

The Uncertain Future of Coding Careers and Why I'm Still Hopeful

2025-06-27T00:00:00Z

A friend of mine, bright, driven, and relatively new to programming, asked me a heavy question the other day. “Did I make a mistake? Did I choose the right career?”

The question hung in the air. It wasn’t born from a bad day or a frustrating bug. It came from a much deeper place of anxiety, one that I suspect many in our industry are feeling right now. They saw recent waves of layoffs, they read the headlines about Artificial Intelligence, and they felt the ground shifting under their feet. The promise of a stable, in-demand career in tech, which seemed like a sure thing just a few years ago, now felt fragile.

“I’m so early in my career,” they said, “I worry if I’ll even have a job in a few years. It’s hard to stay motivated.”

I had to be honest. I hear them. Loud and clear.

I’m no expert, and my perspective is limited to my own journey, roughly 28 years in the tech world, nearly 15 of those as a full time software developer. I’ve seen a few cycles of boom and bust, but I’ll admit, this moment feels different. When I first got access to GitHub Copilot a few years ago, I had my own panic. I’m in my 40s. Was I becoming a fossil? How could I keep up?

That initial fear, however, eventually gave way to something else, a fire. It was a rallying cry to push myself, to embrace my love for learning, and to continuously grow. It reinforced a mindset I’ve tried to cultivate over the years, to constantly work to make my current role obsolete, because in doing so, I’m constantly working my way into my next one.

This is the sober part of the conversation, the industry has pendulums. Companies hire like mad for whatever reason, and then they overcorrect with layoffs. It’s a stressful reality. Imposter syndrome, that nagging feeling of being a fraud, doesn’t go away. I still feel it. But over time, I’ve learned to reframe it. Instead of feeling overwhelmed by all the brilliant people around me, I now feel a sense of awe and a desire to learn from them. It’s fuel.

But what about the elephant in the room, AI? My friend’s biggest fear was that AI will simply do what’s expected of a more junior engineer, making their role disappear.

This is where my hope for the future comes in.

I don’t believe we’re heading for a world where artificial general intelligence (AGI) makes human ingenuity obsolete. Look closely at every major breakthrough, even those in AI-driven medicine. It’s still humans pointing the AI down the right paths. Human creativity is the spark.

What I see is a future where AI handles the grunt work, freeing us up to focus on the truly human part of creation: the next step, the novel idea, the new invention. If we don’t have to spend five years of our early careers doing repetitive tasks, that isn’t a threat, it’s a massive opportunity. It’s an acceleration of our potential.

This led me to a profound realization that now guides my work. We are all, collectively, building a giant, shared brain.

Every time you write a blog post, answer a question on a forum, or push a project to GitHub, you are contributing to this massive corpus of human knowledge. The next generation of AI models will ingest that information. Your solution, your idea, your unique way of explaining something, becomes part of the shared intelligence of our species. When someone else, somewhere else, asks a question that overlaps with something you shared, they’ll be able to build on your work.

We are not just leveling up ourselves when we write and share; we are leveling up all of humanity.

So, how do we thrive in this new world?

First, we must become masters of context. The effectiveness of AI hinges on the quality of the information we give it. I’ve started obsessively collecting my own context, transcripts, notes, ideas, with the goal of building a personal, searchable database that I can use to augment my own thinking and my interactions with AI.

Second, we must learn to be shepherds, not just button-pushers. For those of us who write code, this means getting exceptionally good at describing problems and guiding AI to generate solutions. For our colleagues in non-engineering roles, it means learning to see opportunities for automation and building the AI agents to handle them. We all need to adopt a mindset of invention.

Finally, we must guard against brain atrophy. We can’t let the tool do all the thinking. Use AI as an accelerator, a tireless research assistant, and a pair programmer, but never as a replacement for your own curiosity and ingenuity.

So, did my friend make a mistake choosing to be a programmer?

Absolutely not. The barrier to entry for creating things with software will get lower, but this doesn’t devalue the profession, it transforms it. The demand for people who can solve problems, think critically, and apply human ingenuity will be higher than ever.

The future of this career isn’t about being replaced by a machine. It’s about being amplified by one. Our challenge, and our great opportunity, is to learn how to contribute to that giant, shared brain and use its power to build things we can barely even imagine today.

Footnotes

Junior engineers are still essential (businessinsider.com)
Copilot boosts satisfaction and productivity (github.blog)
Copilot makes devs ~55% faster (arxiv.org)
Copilot improves speed, solution quality (arxiv.org)
Copilot training data includes public GitHub repos (linearb.io)
Large language models trained on Stack Overflow, GitHub, Wikipedia (arxiv.org)
Layoffs in 2023 hit 262,735 (techcrunch.com)
Tech layoffs in 2024 (fastcompany.com)
Over 62,000 layoffs already in early 2025 (nerdwallet)

Feedback

Feedback is welcome: discussions/2

Thank you for your time 🙏

Peer feedback

2023-04-25T00:00:00Z

It’s that time of year again and I’m asking for peer feedback and writing feedback for teammates and realized I’ve learned a few things about this process over the years that I think are worth sharing.

Asking for peer feedback

A close teammate and friend @kmcq gave this piece of advice recently and it really stuck and has made this review cycle at work much more straightforward and enjoyable:

One thing that I’ve found helps me write better peer reviews more efficiently for folks is for the requester to mention something that they’d like me to highlight: a project, quality, or whatever that I can speak to that adds evidence to what they’ll be writing themselves. This helps focus things and saves a lot of time.

I took that idea and ran with it and when I started asking my peers for feedback I included links to things I wrote or code I shipped that they could reference.

This greatly reduces the burden on the people you are asking but at the same time I don’t want to limit what they include in their feedback, so my requests went something like this:

Would you be willing to provide me peer feedback? The feedback form has pre-defined questions but here are some potential areas from our IC expectations that I would appreciate feedback on and links to work related to those areas that I completed during this review cycle:

Leadership and Communication

Provides substantial technical leadership to help others learn and grow

example 1

example 2

Technical Contributions

Demonstrates deep knowledge of data – knows what data is needed, how to find new or missing data, connects disparate or ambiguous data

example 1

example 2

Typically when I provide feedback I focus it on just one expectation or project so you could just pick one of those examples above that you feel comfortable speaking to or choose something else entirely. Critical but constructive feedback is welcome and desired. If there is something I can be doing better for you or the team please don’t hold back.

I would of course be happy to give you peer feedback if I can be of service.

Writing peer feedback

I’ve been writing peer feedback two to four times a year for up to a dozen individuals for the majority of my 11 years at GitHub. Here are a few guidelines I use today that I’ve learned over the years.

When someone asks you for peer feedback, ask them to apply the advice above! It’s a lot easier and faster to write feedback when the range of possibilities has already been narrowed down.
Address the feedback to them and not some third party like their manager.
- Instead of: “I appreciate how Rachel gathers requirements from stakeholders and delivers high impact results.”
- Prefer: “Rachel, I appreciate how you gather requirements from stakeholders and deliver high impact results.” This feedback is for them—not their manager.
There should be no surprises when giving constructive feedback during a review cycle. I like to reinforce feedback I’ve already given during the cycle, and if possible, provide examples of how I’ve seen them improve—and encourage more of that behavior.

Year in review

2017-12-30T00:00:00Z

This year flew by with a couple life changing family events, several projects shipped at work, and a lot of learning.

Family

We took two family trips to Florida this year to visit Natalie’s parents. The first trip was after her father found out he had cancer and the second trip was to help her mom pack up and move after he passed away. Of course these weren’t easy trips but I cherish the time we had with them.

Adalyn is growing up faster than I can comprehend most days. She’s opinionated, independent, and can be sweet and then harsh in the span of a few seconds. Right now I’m trying to learn how to help her concentrate on a task or project for more than a few seconds at a time.

In August Natalie and I celebrated our tenth wedding anniversary (and fifteenth year together). My mom flew in to take care of Adalyn so that Natalie and I could get away for a few days. We flew to Portland and had a great time exploring a new city kid free!

The final piece of big news is that Natalie is pregnant and due in April!

Work

I can’t go into detail about most of my projects now that I’m on the security team at GitHub. I still write blog posts regularly but they only get posted to a private work blog. What I can talk about here is some of the cool tech I’ve been learning and using.

React, GraphQL, and design

One of my responsibilities is building workflow tools for a team of analysts. Most of these workflows are queues and the analysts have to review items in the queue as quickly as possible.

We chose Rails with webpacker and a React frontend implemented in Typescript that reads from a GraphQL API using the Apollo client library. We’ve been able to build super fast and information rich user interfaces with this tech stack and we’re loving it for the most part.

One thing that hasn’t worked great has been combining multiple API’s into a single unified GraphQL API, specifically re-exposing the GitHub Platform in our apps GraphQL API. We’ve had to duplicate a lot of the objects the GitHub Platform exposes and whenever we want to expose a new object or field we have to touch half a dozen places in our codebase.

Thankfully the folks over at Apollo have built a server side solution but it’s implemented in javascript so we’re planning on swapping out Rails in our stack for a node app. We believe schema stitching will have a significant impact on our development speed and maintainability.

I’ve also spent a good deal of time reading about user interface design and applying that knowledge to the analyst workflows. I started by reading through this site from 1999 by Jenifer Tidwell and am now reading her book Designing Interfaces: Patterns for Effective Interaction Design.

Machine learning

We’ve deployed multiple models to production now and have pipelines for training, testing, tuning, and deploying new models. While I haven’t been very involved with the actual model building process I have been spending a lot of my time developing new features for us to use in our models.

During model development our ML stack is Presto, Jupyter, and scikit-learn. When it’s time to put things into production we use Airflow to train and tune models on a regular schedule and then the models are deployed as microservices in our kubernetes cluster.

Stream processing

Over the past few months we’ve switched to publishing our signals as protobuf messages to kafka so that we can use any number of consumers and start experimenting with stream processing.

We’re currently running two types of stream processors. The first is a Ruby app using the Racecar gem. This app has let us experiment quickly with new streams and has helped us enable everyone on the team to do some basic stream processing.

The second one we’ve been experimenting with is Flink. It is way faster and has many more features than our simple ruby consumer app but we’re still ironing out the development process for the rest of our team as you have to write Flink apps with Java, Scala, or Kotlin. Our initial spike with Flink was in Scala but recently we’ve been writing apps with Kotlin which I think we’ll end up preferring to Scala or Java.

2017 Reading List

Stop, Start, Continue for 2018

I need to stop hurting my health with snacks and sugary drinks and stop working late nights and being immobile for hours on end staring at my laptop.

I would like to start exercising consistently, finding medical help for ongoing pain, spending more time playing with Adalyn and hanging out with Natalie, and interviewing again.

I’m going to continue studying machine learning and learning new technologies while consistently shipping at work, supporting my family and my teammates, and taking time to reflect and evolve.

Thank you!

Thank you to everyone who helped me through 2017, especially Natalie and Adalyn, my parents, and my teammates at GitHub ❤️

Ten Years a Software Engineer

2016-12-05T00:00:00Z

Ten years ago I started programming professionally and now I’m a Senior Engineer at GitHub. This blog post begins with a retrospective and ends with what I’m looking forward to in the future.

How did I get here?

Growing up I was always building, repairing, using, and teaching people how to use computers. With a steady stream of spare computer parts from my Uncle John and encouragement from my parents it was easy to get started and advance quickly. Most of my friends were into computers too and a couple of them got into software development but for some reason I didn’t start considering it seriously until 2006. I had done some html, css, and javascript hacking starting in the late 90’s but everything I had built up until 2006 was for myself (like my first blog).

In 2006 everything changed when customers of my company SabreTech started asking if we could build software for them. The opportunity to make money was enough to get me interested and I asked my friends Christian Metts, Daniel Parker, and Joshaven Potter for advice and help. With their help we shipped a couple of projects for customers (foreverrememberme and sixsigmaforms) and I started to catch the programming bug. That same year I attended the first RailsConf in Chicago and started building software to run SabreTech’s operations.

The first half of 2007 we took on more projects including building a centralized billing system for a chain of tanning salons and a network and computer monitoring system with remote access infrastructure to make helping customers faster, easier, and cheaper. Programming work was still my secondary job though, my primary responsibilities were building, installing, and repairing computers and training people how to use them. At this point I was driving an average of 1000 miles per week for work and I would continue to do so for the next 3 years.

The second half of 2007 brought major life changes including getting married and moving to Elkhart, Indiana. Shortly after moving I did a google search for “ruby south bend” and came across the SBRB group that met at the University of Notre Dame. I attended my first meeting that fall and met John Nunemaker and Steve Smith.

Over the next three years I would continue doing programming projects for customers (jukeman), for my business (suitecs), for family (globalauto), and one little side project with John Nunemaker and Steve Smith.

That little side project turned into a job offer in late 2010 and I sold my share of SabreTech to my business partners and started working full time as a software developer at Ordered List. Brandon Keepers joined our team a few weeks after me and then Matt Graham joined a couple of months after that.

Over the course of 2010 our small team built a new product while maintaining our existing products Harmony and Speaker Deck as well as paying our salaries by consulting for companies like Zynga (we helped Zynga scale Words with Friends and helped design and build the javascript version of Words with Friends for Facebook).

Along the way our friends at GitHub noticed our products and our work and in the fall of that year made an offer to acquire our small company. The five of us joined GitHub on December 5th, 2011.

Since joining GitHub I have helped serve our support team, finance team, sales team, customers (specifically GitHub Enterprise admins and Organization admins), and now our security team by designing, planning, building, and maintaining software. I’ve built and led teams along the way but my responsibilities have mostly been solving problems for my coworkers and our customers using software. Earlier this year I was promoted to Senior Engineer. This promotion was especially exciting for me as I looked back at the previous ten years and what it took to get here.

What did I learn along the way?

So. Many. Things.

The importance of mentors as accelerators to growth. Being a leader is often about building trust, giving ownership, and avoiding surprises. That figuring out a process that works for your team matters. That deliberate iteration paired with discipline is a driver for success. That it is important to know your weaknesses and deal find ways to deal with them. That focus is an ongoing struggle. That solving the right problem, doing the simplest thing first, and failing fast are things I value. That listening to friends and family can save your life.

But I’ve written about all of those things already. So what haven’t I written about?

Retrospectives

This blog post is a result of reflecting on the past 10 years so I figured talking about my process for retrospectives would be fitting. Consistent retrospectives are probably the largest contributing factor to who I am today compared to 10 years ago.

Taking time every day, week, month, and year to analyze decisions I’ve made, actions I’ve taken, and the actual outcomes versus my expectations is how I learn what I need to change who I am into who I want to be. A recent example, taken from a personal SWOT analysis, was that I have a tendency to talk over my peers when I get excited about an idea ☹️ As soon as I identified this behavior I started working to change it.

A retrospective goes something like this:

Set aside distraction free time.
Think about something that has happened, whether it was something I did or that happened to me.
Consider the situation, how I feel about it, what I can do better the next time I’m in that situation.
Follow up homework if needed. This could be anything from repeating the situation so I can get better at handling to reading about the subject to learn how other people think about it.

Setting aside time is the hardest part for me, so I’m always keeping an eye out for these distractions:

Social media
Entertainment (TV/movies/podcasts/audiobooks)
Speeding through life

Likewise these are opportunities for reflection that I’m constantly looking for:

After personal devotions (or meditation)
After receiving feedback (good or bad)
After pretty much every conversation
After reading, watching, or listening to something (entertainment made both lists!)
The end of the day, week, month, and year

I like to write down the things I’ve learned through my retrospectives and I often use frameworks like Start/Stop/Keep or a SWOT analysis to help me organize my thoughts and find patterns. This gives me a great opportunity to find repeating themes over the years and track my personal progress. And sometimes it even turns into a blog post 😃

Where do I see myself going in the future?

I’ve been interested in Machine Learning for the past year and recently took a new position at GitHub working on the Security team where I get to use my current skillset and learn some ML and computational statistics techniques. I’m really enjoying it so far and I think I’ll be focused on Machine Learning and Artificial Intelligence for the next few years. I’ve also been hardware hacking as a hobby for the past few years so maybe I’ll get to build that robot butler someday.

Intention vs Perception

2014-11-23T00:00:00Z

It is interesting to study the gap between the intention of communication and the perception of communication in the context of leadership. “We’re going to do X going forward” can be interpreted as “You’re doing a crappy job at Y so we’re going to try X now” or “We decided that it is better to do X instead of Y because we had a meeting you weren’t invited to since we don’t really value your opinion” and the list of interpretations goes on.

In my experience perception rarely matches intention, so figuring out how to change your message to get across what you actually intended is a fun challenge.

There are probably many ways to do it successfully, but I only have experience with a few so I’ll share those (YMMV).

Earn the trust of those impacted

Earning trust takes time. Time spent learning about someone, how to communicate with them, what they are passionate about, understanding their fears.

I like to take people out to lunch, video chat, pair program on a code kata, or help with a problem they are having.

This is the first opportunity to be a servant leader I think. Serve the people you lead and, more likely than not, you will gain their respect and trust.

Give ownership

When someone is going to change the way I work, what I’m working on, or who I’m working with, the psychological toll of that change can be greatly reduced if I feel like I have control over my own destiny.

I look forward to working with leaders that engage me and get me involved in the decision-making process. They ask things like “What do you think about doing X instead of Y; what would be the benefits and what would be the drawbacks?”

Asking for, listening, and reacting to my feedback gives me ownership of an idea, even if it was not my own. Reacting is not necessarily implementing my feedback, but this process of involvement changes the way the idea was communicated and perceived.

Avoid surprises

There is a bonus to talking one-on-one with everyone on a team about an idea before announcing it at a meeting or in an email. You avoid surprises. Turns out not many people enjoy surprises, unless it’s a surprise party.

Having an opportunity to hear and discuss an idea before it is executed gives me time to get comfortable with it. If you have gained my trust then I also feel like I have time to provide feedback before the idea becomes reality.

SWOT Analysis

2014-11-17T00:00:00Z

In college I learned how to do a SWOT analysis and I’ve been using it in one form or another at work and in my personal life ever since.

Update 5-19-2015: The authors of this amazing SWOT guide reached out to me to let me know about their work. After reading my simple how to below, check out their full guide to learn even more.

So why do I care about my strengths, weaknesses, opportunities, and threats? Because I’m ambitious (both a strength and a weakness) and I constantly want to be better at everything I do and I want everything I’m a part of to constantly be improving.

How do I identify and analyze these areas with regard to my personal life or work life? I choose what I want to analyze (myself, a friend asking for feedback, an area of my job) and then sit down with a pen and paper.

I start by drawing a vertical line down the center of the page and then a horizontal line across the page. I now have four quadrants and I label them S, W, O, and T.

Next I write down weaknesses and then strengths in their quadrants. You probably won’t be sharing this analysis with anyone so be brutally honest. Depending on your disposition you may find it easier to write down weaknesses than strengths, or vice versa. With time you’ll get better at identifying both if you practice consistently.

Once I have an understanding of strengths and weaknesses, it is usually pretty easy to identify opportunities that capitalize on strengths and work to turn weaknesses into strengths. Likewise, threats are anything that could turn a strength into a weakness or further entrench an existing weakness.

Now you have to decide what action to take based on the opportunities and threats. After repeating this process a few times you start to see patterns and improve your process even more. Here’s an analysis I did on myself a few months back with regard to my work life.

I noticed after this analysis that my first opportunity, “listen more”, was the most important thing to act on because it addressed several of my weaknesses while building on my strengths and lessened at least one threat. This is one pattern I look for now: opportunities that apply to multiple concerns.

Try a SWOT Analysis next time you want to level up.

Deliberate Iteration

2014-05-22T00:00:00Z

I’ve never been good at New Years resolutions but this year has been different. Starting the year I decided to iterate on life in a much more deliberate way. Here are the results.

Writing

I’m starting to understand how important it is to measure iterations in order to continously improve, instead of just changing things for the sake of change. Writing things down is the best way I have found to measure change.

I’m on my sixth notebook for the year. I write notes when I get up in the morning, when I’m in meetings, when I handle email, when I’m reading, all throughout the day really.

When I sense change I can look back at my notes and see the evolution of an idea. After testing change to see if the results are better than previous results I can identify patterns in the ideas I wrote down and repeat them or discard them.

Scheduling

A few weeks ago I started using a calendar, like for real.

(the first one is what my calendar looked like before I started using it consistently)

The results have been dramatic. My work and life balance feels better than ever, I don’t feel like I’m dropping the ball anymore, and I rarely have to spend time thinking about what to do next.

Before I only used to schedule meetings, dates I had to be at. This barely worked, I would sometimes miss meetings, or I would get anxious because I would suddenly have the feeling I had missed a meeting (even though I hadn’t).

Now every Sunday evening I schedule the upcoming week, from 8am to 5pm every day (±1 hour). I use Calendars 5 on my iPhone and it buzzes me 10 minutes before my next scheduled thing and I use Fantastical on the desktop.

I have trained my brain to rely on the technology, by using it consistently. My error rates and anxious moments have been reduced to almost zero.

I’m getting more done at work, I’m exercising more, and I’m spending more time relaxing. What am I spending less time doing? Spinning my wheels because I’m not sure what to do next.

Meetings

A lot of people have a visceral reaction to the word “meeting”. I used to but I don’t anymore. Every day I set aside time to meet with people. These meetings range from standups to work lunches to video calls to catch up with remote coworkers.

As our company has grown I’ve come to realize how important it is to be deliberate about spending time with people and not just shipping code. Without connecting it is easy to quickly become lost.

Every week I do at least one working lunch, I spend at least one hour on a video conference with a remote coworker, and I attend at least one planning meeting (whether it’s for my team or a team we interact with).

Staying connected to coworkers has improved my mental health 10X as well as improving my value to the company by being able to connect people and ideas.

Conclusion

Figure out how you are spending your time (maybe write it down?) and then look for things to change. Try using tools and doing things you think suck (calendars and meetings oh my!). Measure the results. Do it all over again.

Other notes:

Writing things down is a lesson I have learned before and forgotten. Why is it that good habits are so much harder to practice than bad ones?
I’m writing this during my scheduled time off today 😃
I’m also deliberate about meeting with people outside of my immediate circle, inside and outside of work.
I realize some people will laugh at me for just now starting to use a calendar, but I think I’ve just now grown out of my 20’s “I enjoy chaos more than order” lifestyle.

Robots can do support too

2014-02-28T00:00:00Z

GitHub launched the Atom beta this week and the response has been great. As the first day was winding down a coworker suggested we write an FAQ and add a robot to answer the frequently asked questions in the IRC channel where people were congregating. Here’s how we taught hubot to do support.

Questions and answers

First my coworker gathered the questions that were being asked over and over again:

where do I get an invite?
is there a windows or linux version of atom?
how much will Atom cost?

Next he wrote short and to the point answers:

Are you looking for an atom invite? Go to https://atom.io/ and put in your email, or join the #product-invitations room.
Are you looking for a windows or linux version of atom? We don’t have one yet, but we will in the future.
Were you inquiring in the channel about Atom’s price? We haven’t set a price yet, but expect it will be on par with the cost for similar editors.

Finally he compiled the regular expressions that we could use in hubot to listen for people’s questions and then reply to them with the answers.

/invit(es?|ation)/i
/(windows|linux)/i
/(pric(e|ing)|cost)/i

Training the robot

Meanwhile I used the Getting Started instructions to fire up a hubot instance.

Using npm I installed the hubot and coffee-script packages.

npm install -g hubot coffee-script

Next I created the hubot instance.

hubot --create atomicHubot
cd atomicHubot
git init .
git add .
git commit -m "Create atomicHubot"

Then I started hacking on the script (this is the final iteration with my work and my coworkers).

# Description:
#   Replying to people in atom channels on freenode.
#

module.exports = (robot) ->

  isNotified = (keyword, username) ->
    robot.brain.data[keyword] ?= []
    robot.brain.data[keyword].some (x) -> username == x

  replyTo = (user, msg) ->
    robot.send({user: {name: user}}, msg)

  robot.hear /invit(es?|ation)/i, (msg) ->
    username = msg.message.user.name

    unless isNotified("invite", username)
      replyTo(username, "Are you looking for an atom invite?  Go to https://atom.io/ and put in your email, or join the #product-invitations room.")
      robot.brain.data.invite.push username

  robot.hear /(windows|linux)/i, (msg) ->
    username = msg.message.user.name

    unless isNotified("winux", username)
      replyTo(username, "Are you looking for a windows or linux version of atom?  We don't have one yet, but we will in the future.")
      robot.brain.data.winux.push username

  robot.hear /(pric(e|ing)|cost)/i, (msg) ->
    username = msg.message.user.name

    unless isNotified("price", username)
      replyTo(username, "Were you inquiring in the channel about Atom's price?  We haven't set a price yet, but expect it will be on par with the cost for similar editors.")
      robot.brain.data.price.push username

Every so often I would test the script in hubot’s shell console.

bin/hubot
> where can I get an invite?
hubot> jonmagic: Are you looking for an atom invite?  Go to https://atom.io/ and put in your email, or join the ##atom-invitations room.

Next I installed the irc adapter in atomicHubot.

npm install hubot-irc --save && npm install
git add .
git commit -m "Add irc adapter"

Now I needed atomicHubot to actually live on the internet and connect to the irc channel so I read the Deploying Hubot to Heroku instructions. These required that I have the Heroku toolbelt installed.

Step 1 was creating the application on Heroku and configuring it.

heroku create atomichubot
heroku addons:add redistogo:nano
heroku config:set HEROKU_URL=http://atomichubot.herokuapp.com
heroku config:set HUBOT_IRC_NICK=atomicHubot
heroku config:set HUBOT_IRC_ROOMS=#channel-name
heroku config:set HUBOT_IRC_SERVER=irc.freenode.net
heroku config:set HUBOT_IRC_UNFLOOD=true

Step 2 was deploying to Heroku.

git push heroku master

That was it, I didn’t have to do any trouble shooting, atomicHubot connected to the irc channel and began fielding questions!

Conclusion

Adding this hubot to the irc channel helped reduce the number of questions we had to answer and increased the speed at which common questions were answered.

There are probably easier ways to setup auto reply answers in irc channels but hubot is a tool I’m familiar with and love to hack on. It only took a few minutes to setup and I’ll probably use the same technique in the future.

This may not work for everyone but hubot sure helped out in a pinch, give it a try sometime. For tips on writing hubot scripts see my post hubot Scripts Explained.

Sleep Apnea Survivor

2014-02-13T00:00:00Z

Almost two years ago a friend and my wife saved my life. They got me to go see a doctor because my sleep was a mix of bone rattling snores, deathly silence, and gasps for air. If this sounds like someone you know, help save a life.

I should have listened to her

She wouldn’t say “I told you so” but I am certainly guilty of not following my wife’s advice several years ago to go see a doctor because I snored so loudly.

I should have had more empathy for her situation, struggling to get sleep next to a roaring locomotive. Some nights she would go sleep in another room so she could be rested enough in the morning to go to work.

Resorting to the bathtub

Then there was a night in Lansing Michigan where I shared a hotel room with three friends while attending a tech conference. In the morning I found one of them sleeping in the bathtub, another with headphones on, and the other with his head wrapped tightly in a pillow.

When they woke up they were exhausted, trying to laugh it off in order to resist the urge to kill me (something discussed during the night). They described my sleep as snores loud enough to shake both beds in the room, interspersed with moments of sweet blissful silence, followed by sucking gasps for air.

Death as a motivator

Through all of this I still hadn’t taken the time to see a doctor. I didn’t think the snoring and silence were affecting my daily life, I wasn’t tired during the day, and going to see a doctor was a pain and would cost a lot of money.

Plus I had read up on sleep apnea treatments online and the thought of wearing a mask at night sounded awful. It seemed like all my searching just turned up stories of abandoned CPAP machines.

Finally a friend and coworker told me how his father went to bed one night and never woke up the next day and sleep apnea was the likely cause. This was the motivation I needed to finally go see a doctor.

Sleep studied

In the spring of 2012 I had my first sleep study. I walked the two blocks from our home in Elkhart to the hospital, where they set me up in a small room that looked like a hotel room. Before going to bed they connected two dozen sensors to my head, chest, and legs.

About 6 hours laster I woke up to go to the bathroom and they said they had enough data and sent me home. They told me I would hear back from the doctor in about two weeks.

You are not my patient

The afternoon after the sleep study I received a call from the doctors office asking if I could come in the next day. This was a surprise but I guessed the doctors business was just running a little slow so the sooner they got me in the faster they could collect their money.

I arrived at the doctors office the next day, they took my weight, showed me into a small room, and then the nurse had me do the Epworth test and said the doctor would be in shortly.

When the doctor entered the room he looked up from my chart, concern on his face, then did a double take when he saw me. He looked as if he was about to turn and leave but asked “are you Jon Hoyt”? I answered yes and the concern on his face turned to a look of confusion, but he sat down and the appointment proceeded.

He explained that based on my study he was expecting a seriously overweight and exhausted male, someone over 300 pounds that looked like they hadn’t slept in years.

Diagnosed

This is when I learned just how close I came to death every night. The doctor explained that I stopped breathing 70 times per hour on average and my brain had to wake up just enough to kick start my breathing every time. This also meant I rarely, if ever, got the deep sleep we need to be truly rested.

The doctor prescribed a CPAP machine and another sleep study to get the machine configured to the right settings to help me overcome my severe sleep apnea.

10X your life

Within a week of getting the CPAP my life and my wife’s were completely changed. She was no longer fighting with the locomotive next to her and I was getting the deepest and most restful sleep I’d had in a decade.

I went from 8-10 hours of sleep per night (I sleep without an alarm clock) to 6-8 hours of sleep per night and felt more rested and smarter. Yup, I felt smarter. I could reason out harder problems while programming, I could retain more information throughout the day, and I could communicate more easily at work.

Almost two years later I can’t imagine life without my CPAP. So cheers to life, to sleep!

New Team and Lessons Learned

2013-09-16T00:00:00Z

The past few months I have been building a new team at GitHub focused on solving problems for our business teams. Here are a few valuable lessons we learned along the way.

Solving the right problem

We solve problems for a living and we have one major constraint, our time. This means we need to be thoughtful in choosing which problems to solve. We cannot solve them all.

We decided to solve employee expenses at GitHub by building our own expensing system. We had evaluated 3rd party services and while they did 90% of what we needed, that last 10% made it seem like it was worth doing on our own.

What we failed to account for were the other opportunities, the other problems that needed solved, that ultimately would have a more lasting impact on GitHub.

If we use our company vision, to help people build software better together, as a framework for deciding what to work on, choosing the right problem to solve becomes much easier.

We should be sensitive to opportunity costs. Solve the problem that will have the greatest impact with the lowest cost.

Failing fast

After choosing the wrong problem to solve we did not set clear goals so that we knew what success or failure meant. As a result it took us four months to realize we were working on the wrong thing.

Our first goal was to ship a system that received receipts, connected them to transactions, provided automatic and manual classification, and then entered the data into our accounting system.

The more I learn about software development, or solving any problem really, the more I realize a winning percentage requires breaking down problems (and their solutions) into smaller and smaller pieces. Shipping quickly and constant iteration mean faster course corrections and less costly failures.

The fact that we could not easily break the expensing problem down into smaller pieces should have been a red flag.

We can reduce the costs of failure, both emotionally and economically, if we fail fast. We can’t fail fast unless we ship quickly and iterate.

Do the simplest thing first

We also started building a platform for different teams (and apps) at GitHub to be able to easily invoice customers. We dreamt up the perfect platform for invoicing, without having tried the simplest thing first.

The lie we often believe is that we understand what our constraints will be in a week, or a month, or six months and therefore we can save time by optimizing early. The truth is that we cannot foresee the future.

In the end we learned that invoicing integration needed to be built inside of the products it serves first. After it has been proven it can possibly be extracted into a shared service. This sounds like more work in the long run, but ultimately this process can adapt to change more quickly and easily.

One more thing

We could have avoided a lot of heartache and wasted resources if I had sought mentorship from people with more experience and context at GitHub.

For long term success I need to constantly be learning, which means keeping an open mind and a humble spirit. I look forward to the journey \m/

Business With Pleasure

2013-05-15T00:00:00Z

Hi, my name is Jon. I’m an addict. It does not matter what it is—if it makes me feel good, I do more of it.

But I Love It So Much!

I love my job, or more specifically, I love the work I get to do every day. Combine my love for work with my addiction problem and I end up working too much and spending too little time with my wife, or reading a book, or taking a walk.

When things are going well at work I have a sense of accomplishment, which feels good, and I want more. How do you get more of something? You just keep doing the same thing over and over again that got you that good feeling, right?

Being Honest With Myself

Right now I have no problem identifying that my line of thinking—doing more of something will result in more pleasure—is wrong. When I am in a destructive cycle I am completely blind to this fact.

A destructive cycle is wanting one thing too much and being blind to the costs of achieving it. We also call this being obsessed with something. Ultimately these destructive cycles lead to some sort of meltdown for me when increased input does not lead to an equal or greater increase in output.

During a cycle I can’t stop thinking about whatever I’m obsessing about; I bring it to the dinner table, I bring it on a date, I go to bed with it. This damages my marriage and my mental health.

Thankfully I am getting better at recognizing and breaking these cycles. I can’t take the credit though—my wife usually notices and starts to warn me early on. Learning to listen to her concerns is something I need to get better at. My last obsession lasted about ten days before she got through to me and I recognized the error of my ways. That was yesterday.

Shortening the Cycle

There are a few things I am going to try to shorten this cycle. The first is obvious: listen to my wife. But what if you don’t live with someone?

Recognize the signs. If I am spending less time doing things that relax me, like reading, walking with my dogs, or doing chores around the house, these are pretty good signs I’m not balancing work and life very well.

I’m trying out a checklist of sorts. It is just a long list of non-work things that I can do each day. I made this list by observing what has been healthy for me in the past. I’m not going to check off everything on the list each day, but doing three or four a day is a good sign, and doing one or none is probably a bad sign.

Make yourself accountable to your peers. If you know your signs, ask a coworker and friend to watch out for them. Most of the time someone other than yourself will recognize the signs much sooner than you will. There is a caveat: if you are going to make yourself accountable, you have to be willing to listen when they warn you.

Getting it right feels great too. Excuse me while I add blogging to my list of non-work things to do.

Focus

2012-09-07T00:00:00Z

We just finished shipping a six month long milestone on one of our support tools at GitHub. One lesson I learned along the way was focus.

Make a Commitment

When I first heard about this project, the tool that handles all incoming support requests at GitHub, I was immediately intrigued and volunteered myself to help. Sitting down with the person who had developed the tool to that point and the support team, we came up with a few core things that had to happen, plus a lot of higher level todos.

At the time, our support tool was just a front-end to a popular customer care service called Tender, that was actually built by a couple GitHub employees in their previous lives. The service had done its job for a long time, but it was clear that our needs were changing, and that we couldn’t rely on a third party service to meet them.

So, I made the commitment to help achieve this goal and get our support system running on its own as a full fledged application inside of GitHub. I am not actually sure if I would have made this commitment if I had read through the codebase and understood what a long road it would be. Thankfully, in my gung-ho sorta way I just signed up on the spot.

Frame All Questions & Answers

Having made the commitment, I dove into the project head first. I quickly became the primary developer on the project, with people coming in from other teams to help for a few weeks before returning to their other work (thankfully @spicycode joined later as a full time member of the team). Along the way I learned that being the primary person responsible also meant that people came to me with their needs and wants.

Initially, being a people pleaser, I did everything in my power to fulfill their wishes and desires or promised to work on what they needed later. Quickly this became unsustainable and I became frustrated with my inability to fulfill those requests.

Then I learned the right way to answer questions when asked. I had to frame every question, every want, every wish, in the context of my original commitment. Would satisfying their need further our core goals, and did I have the resources necessary to accomplish it?

Learn To Say No

Most of the time during the last six months that answer ended up being no. This was especially tough for me, I hate saying no, but I had to learn how to do it or risk losing my sanity and disappoint a lot of people.

Thankfully in many cases I didn’t have to say a flat no – instead, we would channel the energy and idea into a feature request that we could talk about more down the road. All of these feature requests were recorded in GitHub Issues and revisited over the following months, taking new shapes, and in some cases being made obsolete by better and newer ideas.

Along the way, we implemented just enough to keep our support team happy, with all of their hair intact. Mostly, we focused on our core goals.

Conclusion

Last night at midnight we flipped the switch to route all support requests thru our new backend. We still use Tender in a limited capacity for old discussions that are still open, but as time passes those will be archived and eventually we will be able to remove Tender completely as a dependency.

In six months, we laid a solid foundation for the future of support at GitHub by staying focused.

My Trip to Verona

2012-05-19T00:00:00Z

As my plane broke through the clouds, descending into Verona, my eyes were met with seemingly endless farm land, a patchwork quilt, broken up by small patches of trees and wandering erratic roads.

Day 1

We landed at the small airport and for the first time in a decade I felt like a foreigner. I was in Verona for jsDay, having been given the opportunity to speak.

After exchanging dollars for euros I hailed a cab. My driver must have been training for the grand prix as we zigzagged and raced around cars at 140km/h. The exhilarating ride ended at the hotel and my original notion that Verona was mostly flat was thoroughly dispelled.

Soon I met with my coworker and his wife who were in Verona on holiday and we jumped on a bus for Lago di Garda. We spent the afternoon catching up, enjoying the scenery, and eating the local fare.

Jet lag began to sneak up on me as the sun moved into the western sky. We returned to the hotel and began making dinner plans, but before we could execute I ran into other speakers from the conference.

Introductions were made, plans were changed, and the spritz began to flow. At a local Pizzeria, one among hundreds in a several kilometer area apparently, we feasted on thin crust delicacies.

We talked into the night, closing the pizzeria and then the hotel bar. A rag tag group of many nationalities, daring each other to try the grappa.

Finally around 3am I collapsed into bed, exhausted from the last 37 hours of travel and new culture acclimation.

Day 2

The conference began with a spritz. The talks were great and it was refreshing to catch up on the world of Javascript since I’ve been so deep in Ruby for the past six months. Twice I had to retire to my room to lay down for a bit, jet lagged and exhausted.

Lunch was catered by the conference center and I mostly feasted on salad, cuts of meat and cheese, carrots, and cooked greens. Red wine was served and rivaled anything I’ve had back home.

At this point I must have been meeting new people at a rate of six or more per hour. English truly is the international language, at least in the programming community.

In the evening they took all of the speakers to the tallest tower in Verona, where I scaled 368 steps and then faced one of my worst fears, heights. It is so strange that I have no problem getting in an aluminum tube that hurtles around the world many thousands of feet above the ground without a second thought, but looking down from a twenty story tower makes me weak in the knees.

After descending we walked across the piazza and sat down at the finest restaurant in Verona. The first glass was filled with Prosecco and I began meeting everyone around the table. Two Californians, a few from Italy, a couple from Germany, and the GitHub delegation.

We all enjoyed conversing, the three course meal and dessert, and of course more red wine. The meal was good but I felt like it was not much different in style or quality from what my wife and I cook at home. The dessert on the other hand, a cream with nuggets of pure chocolate heaven, was fantastic.

After dinner we were bussed back to the hotel and a large number of us headed back to the pizzeria from the pervious night to join the conference attendees. I met more people, sampled the local beer, and once again we closed the place.

Once back to the hotel I settled in at a table in the bar with a Norwegian living in Italy and a Belgian living in Switzerland. We talked into the wee hours of the morning over a couple of beers, discussing everything from nationalized healthcare to the perfect bolognese recipe.

I finally climbed the four flights of steps to my room around 4am and kissed the mattress.

Day 3

Going to bed so late prevented me from waking up in time to see Douglas Crockford talk in the morning, which was definitely a disappointment. I did make it to a few talks however and it was interesting to see what libraries and tools people were using around the world.

Right before my talk I took a power nap and awoke with an idea for how to engage my audience a bit more.

Before leaving my room I grabbed some mostarda I had purchased and on the way to the conference rooms I ordered a spritz from the bar.

As I began my talk about Hubot the robot butler I walked out into the audience and asked whether they liked it when someone did something nice for them. They didn’t answer immediately so I singled out one young lady and asked her if she would like the mostarda or the spritz. She said either so I gave her the spritz and then held up the mostarda and asked who wanted it. A gentleman in the back said sure and I passed it to him and then headed to the front to start my talk. I had broken the ice, demonstrated a servants heart (a butlers heart!), and calmed myself down in the process by having some one on one interaction with the audience.

It felt like the rest of my talk went really well, my energy level was high, I didn’t stumble, and I actually hit my allotted time perfectly! There were even a few questions and light applause. But later I noticed there was only one tweet and no one really came up to ask me more about Hubot, so I’m wondering if either I spoke too quickly and was hard to understand or if my audience just didn’t really need their own robot butler.

After the talk the usual wave of relief washed over me mixing with the waning adrenaline. Now it was time to prepare for hosting a GitHub drinkup!

I found a group to have dinner with and we began our trek across the city. We sat down to a nice meal and the conversation was relaxed. Then I left them a bit early to ensure our venue was ready for the drinkup.

Arriving at the Kulmbacher Bier-Haus I found my coworker and his wife already there. I went inside and made friends with Tony the bartender, an energetic young fellow with blond hair. The entire staff were dressed up in cheesy Bavarian garb that put a smile on your face.

As the designated hour approached people started arriving and we took our place in the back of the restaurant. My coworker and I took turns greeting each new group that wandered in, asking them what they were working on, what they were excited about in their careers, and answering any questions they had for us. One question was oft repeated: “how do I sell my boss or clients on using git.” I honestly struggled to come up with anything they hadn’t already tried. Definitely something I need to study more and work on, as I haven’t ever had to sell git to a boss or client, I just started using it and didn’t give them a choice. Unfortunately that doesn’t work for everyone.

After the successful drinkup a small group of us migrated to a quiet watering hole down the road, continuing unfinished conversations over a grappa.

The bar closed and we walked back to the hotel, me in the lead, arriving back at nearly 4am. With jsDay over I rested my head on the pillow and had my first good long night of sleep since arriving.

Day 4

As my eyes opened I realized it was nearly lunchtime, so I jumped up, dressed, and grabbed my Kindle. Leaving the hotel I found myself heading back to the trusty Pizzeria San Marco. I ordered wine and a pizza with prosciutto, fungi (mushrooms), and mozzarella. I spent my lunch reading Objects on Rails and thinking.

When I was done a nap seemed in order so I returned to the hotel and layed down for a few more hours. Waking up for the second time that day I wasn’t sure what to do so I loaded my messenger bag with laptop and Kindle and headed towards the city center. It was a fascinating hike with beautiful sites and delicious smells, set to a soundtrack from my iPhone. I started with Rome and then moved on to The Sulton of Swing.

While crossing over the Ponte Pietra bridge into the touristy center I saw many people with Gelato so I tracked down the source and bought a small cup of Strachiatella, then found a bench overlooking the river and took my time enjoying the purchase. Around dinner time I found a touristy place and had a somewhat awful meal (never go touristy!).

Dinner complete I trekked back to the hotel and found a table in the bar to sit, read, and relax at. I enjoyed my last glass of wine in Italy (for this trip at least) and read Practicing Ruby articles and watched Destroy All Software videos. Completely exhausted from socializing I avoided the party that night and retired to my room early.

After a few short hours of sleep I rose, packed, and grabbed a much more relaxed cab ride to the airport.

As my plane rose into the sky I said “Ciao Verona” and began writing my tale.

HUBOT img me woman laughing alone with salad

2012-05-19T00:00:00Z

In the past month I’ve had the opportunity to present this talk twice, first in London England and then in Verona Italy.

Before joining GitHub I met Zach Holman from GitHub at a conference in Colorado and heard about Hubot. As soon as Hubot was released as open source we started using him at Ordered List and I blogged a simple script writing tutorial, which is still my most popular blog post day to day.

After joining GitHub I got up the nerve to write and submit a talk proposal and lo and behold two out of three of the conferences I submitted to accepted my talk. I gave this presentation first in London at DevsLoveBacon and you can find the video of my talk on their site. A few weeks later I traveled to jsDay in Verona Italy and presented a second time!

Here are the slides from my presentation.

If you have any feedback on how I can make the talk better or any questions about Hubot please send it via Twitter @jonmagic.

Speaker Deck Goes Full-screen

2012-04-04T00:00:00Z

I’m really excited to let you know that we’ve added full-screen support to presentations on Speaker Deck. This feature has been percolating for awhile, going thru several iterations before we found a solution that we really liked.

We are using the new full-screen API’s available in Webkit based browsers and Firefox. There were a few obstacles we had to overcome, mostly just learning how the API’s actually worked, specifically how to make an element inside an iFrame go fullscreen (make sure to add the allow flags to your iframe tag).

In the process we learned a ton of great stuff that will let us do some pretty cool things in the future. The way we designed full-screen will let us use higher resolution slides in the future as well (you know, in case we decide to start encoding them at the resolution of that new device Apple just released).

Here’s a presentation I did awhile back, check it out in full-screen!

Scriptular

2012-03-05T00:00:00Z

Ever since Hubot was released I’ve been regular expressing myself. Here is a tool I built to make testing regular expressions in JavaScript easier.

Rubular was my go-to for testing regex in the past, but it’s targeted at Ruby so I went in search of a nice editor for JavaScript regular expressions. Unfortunately my search yielded no results. Fortunately I had the tools and experience to build one!

Scriptular is the fruit of my labor. I modeled Scriptular after Rubular with one major difference: it doesn’t have a backend service—everything runs in the browser.

I am really excited about Scriptular; I think it will be useful for developers everywhere. With its current implementation, you can test how a regex reacts in any browser by loading Scriptular in that browser and testing the regex. In the future, I would also like to have a backend service for testing server-side JavaScript implementations like V8.

So go kick the tires, give it a spin around the block, and let me know what you think. If you would like to help on the project, please check it out on GitHub.

Update: Thanks to @bkeepers for contributing the design.

New Tabs and Cucumber

2012-02-07T00:00:00Z

While working on an internal app at GitHub I had to write a cucumber scenario that ran expectations against a new tab that was opened. Here is how I did it.

The Code

Searching around the internet, I finally found a tip on StackOverflow that got me moving in the right direction. In this context tabs are referred to as windows.

page.driver.browser.switch_to.window(page.driver.browser.window_handles.last)

This code grabs the browser object and calls switch_to window on it and passes in the last opened window.

Now all we need to do is wrap this in a step so we can use it in our scenarios.

When /^I access the new tab$/ do
  page.driver.browser.switch_to.window(page.driver.browser.window_handles.last)
end

The Caveat

This will only work if you are using selenium-webdriver. It will not work with capybara-webkit unfortunately. So I switched to selenium, but I told it to use chrome instead of the default firefox and it still works great!

Capybara.javascript_driver = :selenium
Capybara.register_driver :selenium do |app|
  Capybara::Selenium::Driver.new(app, :browser => :chrome)
end

The Finale

Now its time to see the step in action. Notice I had to tag the feature with @javascript so that it uses the selenium webdriver.

@javascript
Feature: Open a discussion

  Scenario: staff opens a discussion with the mouse
    Given the following users exist:
      | username   | email                 |
      | test-user  | integration@test.com  |
    And I am on the triage page
    When I follow "Can't get git running on my mac"
    And I access the new tab
    Then I should be on the discussion page for "5786909"
    And I should see "Can't get git running on my mac"

The link that I follow opens the new page in a new tab, I select the new tab, then run my expectations against it.

Being acquired doesn't have to suck

2012-01-08T00:00:00Z

It has been a month since Ordered List was acquired by GitHub and our team of 5 joined their team of 50, and it hasn’t sucked at all. Here are some observations on how to remove the suck from acquisitions.

The Suck

My general attitude towards acquisitions the past few years has been fairly negative. I’ve seen too many people and products we love be acquired and the people only stick around until their stock vests and the products are shut down or perverted into something hideous.

With all that negative sentiment you would think I would have fought for Ordered List to remain independent, but I assure you everyone on our team was not only on board with the acquisition but also excited about the opportunity.

The number one problem after an acquisition are differences in culture. From how the individuals and teams work, to how they interact, how they are led, and how they are motivated.

We would not have even considered joining GitHub if there were large differences in culture and any company looking at an acquisition should make sure this is the first thing they research and consider.

The Reality

Both sides in this acquisition did their homework and didn’t just jump in without lots of serious consideration. Putting in this work ahead of time has made the actual integration of our teams virtually frictionless.

My day to day work has not changed and yours shouldn’t have to either. This is definitely something to think about before an acquisition. Do they know what you do best and will they give you the opportunity to continue doing it? Thankfully I’m still working on the products I love and now I have a pool of talent and knowledge 10x greater than before to draw from.

There is definitely more to keep track of since there are more people, more products, and just more going on in general, but the time I spend on that is a lot less than the time I used to spend on client work to make sure my salary got paid. Acquisitions can and should give you more opportunities to concentrate on what you are passionate about.

Yes, it’s only been a month, how can I be sure this acquisition won’t suck? I feel like I’ve been working with these people for a long time, and in a way I have. I have been hanging out with them at conferences, working on open source code with them, and having conversations with them on Twitter for much longer than I’ve been their coworker.

In the tech industry we have and should take advantage of those opportunities. We can follow and get to know people through their code (a great way to use GitHub!) as well as on social networks and at conferences. Do your best to know the people you are getting into bed with.

Conclusion

My attitude towards acquisitions has definitely changed, but only because it’s clearer to me what works and what doesn’t.

Avoid merging teams with drastically different cultures, understand the strengths and weaknesses of the teams on both sides and be committed to letting them do what they do best, and know the actual people you will share the future with.

Assimilating Contributed Code

2011-12-30T00:00:00Z

This year I authored several RubyGems and just this week finally learned how to work with a contributor.

UPDATE: @bryckbost points out that the github-gem does exactly what I wanted to do. See the Fetching and Evaluating Downstream Changes section of the README.

Of course GitHub has the great Merge pull request option when an auto-merge is possible, and I use that quite often, but the workflow on OSS projects sometimes requires you to run the tests locally and make any modifications before merging it.

A quick search didn’t turn up any easy to read instructions, and I’m no git guru, so it took me a few minutes to figure out a simple workflow.

Here is how I checked out, tested, modified, and merged a massive pull request for Ghee from Ryan Rauh this week.

1. Clone my repo and create a feature branch

git clone git@github.com:jonmagic/ghee.git
cd ghee
git checkout -b repos_support master

This creates a new branch called repos_support, based off of master, and checks it out.

2. Pull contributors code into your local branch

git pull https://github.com/rauhryan/ghee.git repos_support

This pulls the repos_support branch from the remote repo and merges it into the branch you have checked out (which we also called repos_support).

3. Run tests, make modifications, commit changes

bundle exec rake
touch OHNOES.txt
git add OHNOES.txt
git commit -m "Added OHNOES"

4. Checkout master, merge feature branch, push

git checkout master
git merge repos_support
git push

Conclusion

This workflow follows the kiss principle, so it worked quite well for me.

Please give me feedback. I would love to hear about how other people accomplish this task, so I encourage you to leave links/tips/tricks in the comments below.

Also be sure to checkout Ryan’s awesome work on Ghee, a simple ruby client for the GitHub API V3.

Twelve (gauge)

2011-12-09T00:00:00Z

Today I hacked together an easy to use gem for accessing the Gauges API.

When I started this morning 12-gauge was the first thing I thought, so I called the gem Twelve (silly I know).

I had fun figuring out the API (with a little help from Brandon) and then writing the gem using some of the proxy object and method missing stuff I was learning a few weeks ago.

Installation

gem install twelve

Usage

Get the client ready:

access_token = "abcd1234"
bfg = Twelve.new(access_token)

Request your Gauges info:

bfg.me

For me I got this back:

{"name"=>"Jonathan Hoyt", "urls"=>{"self"=>"https://secure.gaug.es/me", "gauges"=>"https://secure.gaug.es/gauges", "clients"=>"https://secure.gaug.es/clients"}, "id"=>"...", "last_name"=>"Hoyt", "first_name"=>"Jonathan", "email"=>"jonmagic@gmail.com"}

Next try these:

bfg.clients
bfg.gauges

GitHubber

2011-12-05T00:00:00Z

Today the whole crew from Ordered List joins GitHub!

Ordered List

Last year was a big year for myself and Ordered List. Steve and John launched Harmony in August, I started hanging out with them on a regular basis and began work on Speaker Deck, and the end of the year saw Brandon Keepers and I leaving our own businesses to make OL four strong.

This year was even bigger, launching Gauges and Speaker Deck, adding Matt Graham to the team, and beginning the journey of learning how to work as a cohesive unit. While we learned each others strengths and weaknesses I began my own journey of becoming a full-time programmer that could not only contribute to the growth of our company, but also lead in certain circumstances.

We all dreamed of taking over the world, and we knew we could do it together. We also know it takes time to build something great and that as time goes on new opportunities present themselves. Every once in awhile those opportunities get you even more excited than the dream you are currently living. One year (minus a day) after I joined Ordered List our entire team has accepted the opportunity to join GitHub.

GitHub

This company and the team behind it has been near and dear to our hearts for years. I had the chance to meet and hang out with a few GitHubbers over the last year and have really come to appreciate them as programmers, professionals, writers, and people. When they started talking about their culture at conferences I marveled even more, excited about how they were changing the rules, hiring tons of awesome people, and just kicking-butt.

When the opportunity to join GitHub materialized it sparked an epic discussion about the possibilities. It made sense in so many ways, but whenever you entertain the chance to change course you can’t help but wonder how far you can get on your current trajectory. There were a lot of factors to consider and in the end Steve and John decided that our personal and collective futures with GitHub seemed greater.

Over the past few weeks the details were hammered out and during that time we’ve each had a chance to reset our dreams for the future, while trying to keep the whole thing a secret.

The Future

Right now I have no idea what the future holds, except that it is going to be great. I am most excited about the journey, learning new things, powering thru the hard times, accelerating during the good times, and building something that we can all be proud of.

Thanks again to everyone involved in making this a reality. Watch out world.

Finish Weekend

2011-11-12T00:00:00Z

While I initially had issues with the concept of Finish Weekend, I’m really glad I participated and believe everyone involved is better off for it.

The Who

My friends at Collective Idea have apparently been talking about doing a Finish Weekend for a few years and this is the year they made it happen! They put out the word thru Twitter, friends, colleagues, and a ton of people signed up and showed up!

I met folks from Detroit, Chicago, South Bend, and even as far away as California! There were programmers, designers, editors, math geeks, marketers, and testers just to name a few.

The Why

Finish Weekend was born out of a personal and professional frustration with starting things and never finishing them. What if there was a weekend dedicated to taking something you’ve started, never found time to finish, and actually finish it. Even better, what if there were people around to help you finish it!

Many folks showed up with projects to finish, but what really surprised me were how many people showed up to help other people finish! This brings us to my issue with Finish Weekend.

My Issue

When first told about Finish Weekend immediately I reacted negatively because I believe we should be working hard to finish things every day. I love finishing things. Finishing projects is hard (that last 5% can be excruciating) but the joy you get from shipping feature X, or accomplishing goal Y, is greater than the joy I personally get from starting a project (as much fun as that is).

When I finally got over myself and realized that Collective Idea was trying to help people learn how to finish things I signed up and made the trek to Holland, Michigan. I did not regret it.

The Outcome

Today I saw a great group of people with greatly varying skillsets and backgrounds come together with one purpose, to finish things. We had people building video based web apps, crazy poetry recombinators, iPhone apps, and even a bond trader learning Python to automate a process that has taken him 1.5 hours every work evening for the last two years in Excel.

I was able to teach basic programming concepts, performance measuring and optimization, even cut up a mockup into HTML/CSS, and paired with my coworker on some tech that will hopefully help power our products into the future.

Collective Idea nailed it with Finish Weekend and my hope and desire is that we take the relationships and spirit of pitching in together to accomplish big and small things and carry it into the rest of our lives and not relegate it to a weekend.

Of course we’ll need reminded every so often. See you at the next Finish Weekend 😃

hubot Scripts Explained

2011-10-28T00:00:00Z

Ok, so now you’ve got your shiny new hubot up and ready to listen to your every command. But what should we tell him to do with our nonsense!

Basics

Scripts for hubot are written with CoffeeScript. This is what a basic script looks like:

# hubot greeting.
#
# (hi|hello) - say hi to your butler

module.exports = (robot) ->
  robot.respond /hi|hello/i, (msg) ->
    msg.send "Howdy!"

Lets break this script down. The first line is just a description of the script. The third line tells hubot what to include in the help (when you ask hubot for help).

The actual code starts on the module.exports line. Every script you make will start with that line.

module.exports = (robot) ->

The next line tells hubot to respond to hi and hello.

robot.respond /hi|hello/i, (msg) ->

It uses a regular expression to parse the text, looking for the words hi and hello. The i after the last slash tells the regular expression to not be case sensitive, so it will also match Hi and Hello.

I like to use rubular for writing and testing regular expressions. Its quick, easy to use, and while javascript regular expressions aren’t exactly like ruby regular expressions I haven’t run into any inconsistencies yet.

Finally we tell hubot to take the message and send a message back.

msg.send "Howdy!"

Respond vs Hear

I didn’t discover this at first and thought that hubot only responded to commands directed at him, but then I discovered robot.hear! Whereas robot.respond only matches messages directed at hubot, robot.hear will run your regular expression against any chat message!

# Hubot has an attitude

module.exports = (robot) ->
  robot.hear /tired|too hard|to hard|upset|bored/i, (msg) ->
    msg.send "Panzy"

See what I did there 😃 Any time someone in our chat room says they are tired, that something is too hard, upset, or bored, hubot tells them they’re a panzy. Oh yeah. This robot butler has an attitude.

Random

I saw this used first in the shipit script, which displays a random shipit squirrel for your viewing pleasure whenever someone says the words “ship it” in your chat room.

# Rodent Motivation
#
# ship it - Display a motivation squirrel
#

squirrels = [
  "/images/posts/hubot-scripts-explained/20100714-d6q52xajfh4cimxr3888yb77ru.jpg",
  "/images/posts/hubot-scripts-explained/20111026-r2wsngtu4jftwxmsytdke6arwd.png",
  "/images/posts/hubot-scripts-explained/Screen_Shot_2011-10-27_at_9.36.45_AM.png",
  "/images/posts/hubot-scripts-explained/squirrel.png"
]

module.exports = (robot) ->
  robot.hear /ship it/i, (msg) ->
    msg.send msg.random squirrels

Notice the array that we create with 4 different shipit squirrel images. Then notice this line:

msg.send msg.random squirrels

The msg object has a random method on it which we can pass an array and it will pick a random item from that array! Super handy to keep things from getting repetitive.

Reply

You can reply to a user by changing the send command to reply like this:

msg.reply "Why thank you sir!"

Replies will be directed at a specific user, example: “@hoyt Why thank you sir!”

Http

So far we’ve only talked about how to make hubot listen and respond in various ways. Hubot really starts to get interesting when we empower him to go out and do our bidding in the larger world though. This is where hubot really starts to become powerful!

# Whois for gems, because gem names are like domains in the 90's
#
# gem whois <gemname> - returns gem details if it exists
#

module.exports = (robot) ->
  robot.respond /gem whois (.*)/i, (msg) ->
    gemname = escape(msg.match[1])
    msg.http("http://rubygems.org/api/v1/gems/#{gemname}.json")
      .get() (err, res, body) ->
        try
          json = JSON.parse(body)
          msg.send "   gem name: #{json.name}\n\
     owners: #{json.authors}\n\
       info: #{json.info}\n\
    version: #{json.version}\n\
  downloads: #{json.downloads}\n"
        catch error
          msg.send "Gem not found. It will be mine. Oh yes. It will be mine. *sinister laugh*"

This script is doing quite a bit so we’ll dissect it line by line.

robot.respond /gem whois (.*)/i, (msg) ->

This tells hubot to look for messages directed at him that have the words “gem whois” and then some string.

gemname = escape(msg.match[1])

Now I grab the gemname from the regular expression. msg.match with an integer will match the captured item from the regular expression. You use parenthesis to capture strings in regular expressions, and they get numbered left to right by however many there are. In this case its the first one, so we pass 1 to msg.match and then assign it off to our variable gemname.

msg.http("http://rubygems.org/api/v1/gems/#{gemname}.json")

Next we tell the msg.http object to use this url, with the gemname interpolated in it.

.get() (err, res, body) ->

The .get() function kicks off the request and returns 3 objects, err, res, and body. In this case we’re only interested in body.

try
  json = JSON.parse(body)
  msg.send "   gem name: #{json.name}\n\
    owners: #{json.authors}\n\
    info: #{json.info}\n\
    version: #{json.version}\n\
    downloads: #{json.downloads}\n"
catch error
  msg.send "Gem not found. It will be mine. Oh yes. It will be mine. *sinister laugh*"

If JSON.parse is able to parse the body then it displays the gem information, if it errors we get the “Gem not found” message.

Advanced HTTP

What if you want to hit an API that requires authentication? Here is a script that uses http basic auth when hitting the dnsimple api to check domain name availability.

# Domain availability via DNSimple, requires you set
# DNSIMPLE_USERNAME & DNSIMPLE_PASSWORD environment variables
#
# check domain <domainname> - returns whether a domain is available
#

module.exports = (robot) ->
  robot.hear /check domain (.*)/i, (msg) ->
    domain = escape(msg.match[1])
    user = process.env.DNSIMPLE_USERNAME
    pass = process.env.DNSIMPLE_PASSWORD
    auth = 'Basic ' + new Buffer(user + ':' + pass).toString('base64');
    msg.http("https://dnsimple.com/domains/#{domain}/check")
      .headers(Authorization: auth, Accept: 'application/json')
      .get() (err, res, body) ->
        switch res.statusCode
          when 200
            msg.send "Sorry, #{domain} is not available."
          when 404
            msg.send "Cybersquat that s***!"
          when 401
            msg.send "You need to authenticate by setting the DNSIMPLE_USERNAME & DNSIMPLE_PASSWORD environment variables"
          else
            msg.send "Unable to process your request and we're not sure why :("

We do the same thing as the last example, grabbing the domain name that is captured by the regular expression, but then things get a bit different.

user = process.env.DNSIMPLE_USERNAME
pass = process.env.DNSIMPLE_PASSWORD

Here we grab some environment variables and assign them to variables. If you are deploying hubot to Heroku then setting environment variables is crazy easy:

heroku config:add DNSIMPLE_USERNAME=john@doe.com DNSIMPLE_PASSWORD=4w3s0m3p4ssw0rd

Next we have to create the auth string that we’ll stuff into the authorization header.

auth = 'Basic ' + new Buffer(user + ':' + pass).toString('base64');

Creating that auth string is some javascript voodoo that took me awhile to figure out, finally finding an article on stackoverflow that had the magic I needed.

msg.http("https://dnsimple.com/domains/#{domain}/check")
  .headers(Authorization: auth, Accept: 'application/json')
  .get() (err, res, body) ->

The really interesting line in the code above is the .headers() line. We can set headers for the http request before calling .get(), allowing us to configure the Authorization and Accept headers! Now the last bit.

switch res.statusCode
  when 200
    msg.send "Sorry, #{domain} is not available."
  when 404
    msg.send "Cybersquat that s***!"
  when 401
    msg.send "You need to authenticate by setting the DNSIMPLE_USERNAME & DNSIMPLE_PASSWORD environment variables"
  else
    msg.send "Unable to process your request and we're not sure why :("

The response (res) object has a statusCode method on it which we can use to match http response codes. Based on the dnsimple api I was able to make a simple switch statement with the correct replies for each status code.

Conclusion

I hope this is helpful to some folks out there. I can’t wait to see what other hubot scripts people write!

Make sure to fork the hubot-scripts repo, add your scripts, and do a pull request once you’ve got them working. The gem whois and dnsimple scripts above have already been accepted into the hubot-scripts library!

Enjoy 😃

HipChat, hubot, and Me

2011-10-28T00:00:00Z

How you can give Siri her very own robot brother with some help from Heroku and HipChat.

Github released hubot this week and geeks the world over have been transfixed by his awesomeness. He’s the second robot butler to enter my life lately, Siri being the first. Together these two fulfill my every wish (not quite) and are at my beck and call day and night (too true).

UPDATE: for a slightly different take try these instructions by @martinciu

NOTE: to learn more about writing hubot scripts read this

Getting Started

The first step is to head on over to the hubot downloads to grab yourself a copy of the latest hubot tarball. Download it and then open your command line to your download folder. It looked something like this for me:

cd Downloads
tar zxvf hubot-1.1.3.tar.gz
cd hubot

Make sure you have node.js and npm installed. I used homebrew to accomplish this.

brew install node
brew install npm

Then you can just run the hubot binary and it should install all the necessary packages and fire right up.

bin/hubot

If you run into any issues at this point please consult the hubot Issues page on Github, because someone has probably already run into the issue.

Configuring Heroku and HipChat

First we need to initialize git for our hubot so he’s actually stored in version control.

git init .
git add .
git commit -m "spawning my first robot!"

Next we create a new instance on the Heroku cedar stack (assuming you already are setup to use Heroku).

heroku create my_hubot_app_name --stack cedar

Then we need to setup hubot and Heroku to connect to our HipChat account.

This requires creating the user in HipChat and then going to your account page in HipChat (https://mycompanyhere.hipchat.com/account/xmpp) to get some values that we’ll need for configuring Heroku.

You’ll also need to go to the Group Admin in HipChat and the API tab to create an API Auth Token. Run the following commands replacing the values with the ones that match in the HipChat settings:

heroku config:add HUBOT_HIPCHAT_JID=<Username>

heroku config:add HUBOT_HIPCHAT_NAME=<Room nickname>
# example: heroku config:add HUBOT_HIPCHAT_NAME="Geoffrey Butler"

heroku config:add HUBOT_HIPCHAT_PASSWORD=<Password you created for hubots user>
heroku config:add HUBOT_HIPCHAT_TOKEN=<Token from Group Admin and API>

We also need to add the RedisToGo addon. (Thanks to Graham Siener for pointing this out)

heroku addons:add redistogo:nano

Now that Heroku is configured we need to slightly modify our Procfile to use the right adapter and name. Mine looks like this:

app: bin/hubot -a hipchat -n "Geoffrey Butler"

Replace Geoffrey Butler with whatever you named the user in HipChat. This should exactly match the Room nickname we set above. Once you’ve updated the Procfile and saved it we need to commit it with git.

git add Procfile
git commit -m "updated Procfile to use hipchat adapter and hipchat room nickname"

Deploying to Heroku

Now we should be ready to deploy.

git push heroku master

This step failed for me at first. I had to edit package.json and change the dependencies section to look like this:

"dependencies": {
  "hubot": "1.1.0",
  "hubot-scripts": "1.1.0",
  "optparse": "1.0.1"
}

The latest version of hubot-scripts blows up on the Heroku Cedar stack unfortunately. So after this step I committed my changes one more time and deployed.

git add package.json
git commit -m "changed dependencies"
git push heroku master

Woot! It worked! Now that its deployed we just need to start it up.

heroku ps:scale app=1

Inside our HipChat rooms Geoffrey suddenly appeared and I was able to talk to him.

@geoffrey help
(thanks|thank you) - say thanks to your butler
<keyword> tweet - Returns a link to a tweet about <keyword>
<user> is a badass guitarist - assign a role to a user
<user> is not a badass guitarist - remove a role from a user
animate me <query>  - The same thing as `image me`, except adds a few
ascii me <text> - Show text in ascii art.
check domain <domainname> - returns whether a domain is available
convert me <expression> to <units> - Convert expression to given units.
gem whois <gemname> - returns gem details if it exists
haters - Returns a random haters gonna hate url
help - Displays all of the help commands that Hubot knows about.
image me <query>    - The Original. Queries Google Images for <query> and
map me <query> - Returns a map view of the area returned by `query`.
math me <expression> - Calculate the given expression.
mustache me <query> - Searches Google Images for the specified query and
mustache me <url>   - Adds a mustache to the specified URL.
remind me in <time> to <action>    - Set a reminder in <time> to do an <action>
ship it - Display a motivation squirrel
show storage - Display the contents that are persisted in redis
show users - Display all users that hubot knows about
translate me <phrase> - Searches for a translation for the <phrase> and then
translate me from <source> into <target> <phrase> - Translates <phrase> from <source> into <target>. Both <source> and <target> are optional
who is <user> - see what roles a user has
youtube me <query> - Searches YouTube for the query and returns the video

Awesome! Enjoy 😃

Mentors

2011-10-20T00:00:00Z

We need more mentors. Mentors help us avoid mistakes and give us guidance on how to be better at our jobs and at life.

My Mentors

The first eight months of my new job at Ordered List I paired with my coworker Brandon three or four days a week. We kept each other on task, but most important for me, he started teaching me the process of writing beautiful and maintainable code. He had years of experience in this industry and a passion for elegant solutions that I didn’t have, but I could learn from him.

While we aren’t pairing as often now, Brandon and I have built a level of trust that enables us to quickly and easily share ideas and continue to educate each other and make better software.

In the last couple months my coworker/boss John has been mentoring me. We meet once a week, either over breakfast, lunch, or just a hot chocolate, and have a nice long chat. We usually cover things we’ve been thinking about the past week, what to focus on in the next week or month, personal goals, even our personal lives. This too has been invaluable for me.

Why Mentors Matter

In my time with both Brandon and John I’ve been able to get someone else’s perspective on how I’m progressing as both a programmer and a person. Looking back I’m completely shocked by how much I’ve changed for the better thanks to them taking the time to care about me and give me feedback that I can act on.

By listening to their advice, which has years of experience and thought behind it, I am able to set a better course for my own life. A good mentor shares what has worked and what has not.

Finding A Mentor

If you have the opportunity to be mentored right now, by someone you respect, seize it. Good mentors are few and far between in my experience. In my current situation I didn’t have to go seeking a mentor, they came to me and offered to help.

In the past I have had to seek out mentors. I wouldn’t be working at Ordered List if I hadn’t reached out four years ago, initially seeking like minded geeks, but eventually finding Steve and John and growing to respect them, so much so that I took advantage of every opportunity to hang out and learn from them.

Final Thoughts

While having a good mentor can be uplifting, constructive, and life changing, likewise a bad mentor can tear you down. Be careful entering a mentoring relationship to ensure the mentor is someone you have at least some level of trust and respect for. If you leave a meeting challenged and excited, things are probably on the right track. If you leave a meeting discouraged and ready to quit, examine whether its your attitude that is the problem or whether you can’t trust and respect your mentor enough to learn.

One on one time with your mentor is essential, so put it on the calendar and stick to it. If you aren’t serious enough to make the meeting happen then figure out why you are resistant and fix it. John and I have to reschedule a meeting every so often, but we try to avoid canceling.

Finally I would just like to encourage you to mentor someone yourself, if you are ready. I am not mentoring anyone at the moment, but I have in the past and I will in the future.

We need more mentors.

Why Should We Write?

2011-10-14T00:00:00Z

Building a career as a programmer requires a lot of hard work, determination, and in my opinion a lot of writing.

How do you build a personal brand online? How do you get opportunities to work on awesome projects? How do you get invited to speak at conferences? Looking at my coworkers’ success I would deduce that you have to work hard on stuff you care about and then share the knowledge you have gained with your peers, writing on a blog for example.

Writing has always been a struggle for me, I was always a math geek, but I cannot use that as an excuse if I want to continually advance my career. If we are working online, building websites, doing design, programming web applications, or working on infrastructure, we need to be writing about our experiences.

We run into new problems every day. More often than not the solution is a Google search away. But when it isn’t and we find a solution on our own, we should be writing it down and sharing it with the world.

Whether it’s writing readme’s for an open source library, blogging about how you solved a problem, or sharing some insight about how to become a better person, I think we should all be writing more and sharing it with the world.

Let’s become better communicators thru practice, making the world a better place while at the same time advancing our careers.

Launching Speaker Deck

2011-10-10T00:00:00Z

Looking back at the last two weeks since launching Speaker Deck.

Launching

Knowing when to launch a product is a painstaking task and ultimately you are never sure if it’s the right time, but at some point you have to pull the trigger. September 26th we finally committed and launched Speaker Deck to the world.

The past two weeks since launch have been pretty intense, we’ve had over 2500 signups and over 1000 presentations uploaded. We’ve received hundreds of emails, people just telling us how excited they are about Speaker Deck and many of them asking for a feature or requesting help. Seeing everyone’s reactions has confirmed in our minds that we weren’t the only ones feeling severe slide hosting pain.

The twitter search for speakerdeck has seen a constant stream of tweets, almost all of them linking directly to specific slide decks, which is awesome!

Fixing

Thankfully Heroku has been a fantastic platform for Speaker Deck so far. During peak traffic we’ve been able to easily scale up both our web capacity (how many requests we can handle from your browsers) and the background worker capacity (where we process your PDFs into individual slides).

No story is complete without some drama though, right? When we opened up signups we almost immediately began seeing presentations that wouldn’t process. Thankfully within a week we were able to roll out fixes that got us past this hurdle.

We also ran into problems with slides acting like they were never processed even though they had. This turned out to be race conditions. In addition, there were issues with caching. There were a couple instances where we cached something and then missed clearing that item from the cache when the item was updated. Hard bugs to track down but easy to fix thankfully.

All in all things went really well, thankfully, since we were all gone to New Orleans for RubyConf and without good internet. Looking back, launching 2 days before a road trip was probably not the wisest thing we’ve ever done.

Future

I’m betting many of you are thinking “how the heck is this sustainable?” I’ll let you know when we figure it out. Seriously though, we do have plans to monetize and I’d like to start talking about them to see what you folks think.

The first idea is just what we’re doing right now, mentioning our other products (Gauges & Harmony) in a very small and tasteful way in the sidebar. For this plan to succeed on its own there would have to be a lot of people clicking through and signing up for our other products.

The second plan is to add pro accounts. We’ve heard a lot of great feedback about bigger features people want, like private presentations that you can share with a select group and also statistics. We’d love to hear more about features you want, especially the ones you’d be willing to pay for.

We of course still have a lot of core features to build, like search, full screen mode, following presenters, activity streams, and so much more.

Conclusion

All of us at Ordered List just want to say thanks. It has been a wild ride and we’ve been blown away by how many people are using Speaker Deck and all the good will that has been coming our way. Thank you for making it a success!

Grim MultiProcessor to the Rescue!

2011-10-06T00:00:00Z

We recently ran into issues with certain versions of GhostScript not being able to convert PDFs into images. Here’s how we solved the problem.

The Problem

Last week we launched Speaker Deck and since launch over 2000 people have signed up and uploaded almost a 1000 presentations. We were using GhostScript 9.04 because it is faster than 9.02 by a factor of two and fixed some processing problems we had experienced converting certain PDFs.

convert: Postscript delegate failed `presentation.pdf': No such file or directory @ error/pdf.c/ReadPDFImage/663.
convert: missing an image filename `slide.jpg' @ error/convert.c/ConvertImageCommand/3011.

Unfortunately we ran into the same processing issue with 9.04 and through trial and error figured out that those presentations that wouldn’t process with 9.04 would process with 9.02. So what to do! GhostScript 9.04 works for most presentations and is faster but fails on certain PDFs where 9.02 actually does work.

The Solution

We are using Grim to convert PDFs into images, so I decided that Grim needed to be updated to support multiple processors. Better yet I thought it would be cool if Grim could automatically try multiple processors if you specified more than one, starting with the first and falling back to secondary processors as needed.

I started working on adding Processors to Grim while at RubyConf and Monday finished up getting it all working. I started by pulling out the ImageMagick and GhostScript specific code into an ImageMagickProcessor class that lets you pass in the path to convert and gs (ImageMagick and GhostScript executables).

Grim.processor = Grim::ImageMagickProcessor.new({:imagemagick_path => "/path/to/convert", :ghostscript_path => "/path/to/gs"})

Once I had that working (super easy thanks to a great test suite!) I started in on the MultiProcessor.

The MultiProcessor accepts an array of processors and uses them in order, falling back to secondary processors when the first in line fails. If none of them succeed it just raises the same error the processors on their own raise.

Grim.processor = Grim::MultiProcessor.new([
  Grim::ImageMagickProcessor.new({:imagemagick_path => "/path/to/6.7/convert", :ghostscript_path => "/path/to/9.04/gs"}),
  Grim::ImageMagickProcessor.new({:imagemagick_path => "/path/to/6.6/convert", :ghostscript_path => "/path/to/9.02/gs"})
])

Monday we deployed Speaker Deck with the updated Grim gem and reprocessed the 13 presentations that were stuck. Every single one of them processed without a hitch!

The Future

Now that the actual processing logic has been split out into easy to build Processor classes, I see us building more processors for Grim. Why not a Quartz processor, or a processor that works on Windows.

If you would like to use Grim in your project or get involved with development just head over to the Grim repo on Github.

Thank You Steve Jobs

2011-10-05T00:00:00Z

When did you start using a Mac? Just wanted to share my story and how Steve Jobs and Apple changed my life.

I bought my first Apple laptop, the 12” Powerbook, in 2002 for $2000. It forever changed my life. Simple, intuitive, and extremely powerful.

Before that I had only ever owned PCs, my first one a 286SX my parents bought in 1987. Before that I had played on 8088’s, playing Frogger and learning a little BASIC.

In the 90’s my uncle John would drop off computer parts at my house and I built many computers, even entering a 386SX in the 4H county fair when I was 10. I won every award you could win by default, not many other 10 year olds were entering computers in the 4H. Not sure if they ever have since in Hillsdale, Michigan.

I remember my first experience with an Apple. There was room full of Apple IIe’s at Kimball Camp in Reading, Michigan. I remember not being impressed, as they were pretty far behind what I was using at the time (486 running Windows 3.1).

Then in the mid 90’s I started using Macs running OS 7 or 8 at Spring Arbor College where my mom went to finish her bachelors. I was impressed even then by the interface, it was just easier to use. But I continued to use PCs for years, becoming a PC technician, and fixing computers and training people how to use them through high school and into college.

Then during my junior year of college (2002) I finally drank the kool-aid and switched to a Mac. I had just purchased a brand new HP and was hanging out with my friend Christian (@mintchaos), who had been a Mac user for life, and noticed how much faster and easier to use his white iBook was. I played with it a bit and the next day returned the HP and bought myself a Mac.

My first Apple computer was the 12” PowerBook. It was awesome. OS X, the PowerBook hardware, and the Apple culture became part of who I was.

I had spent years spending the majority of my time keeping my computers running, keeping my friends, family, and clients’ computers running. Suddenly I found out there was a computer that you could just use to get stuff done, real stuff, like building websites, programming, graphic design, building cool stuff out of photos and video, and the barrier to entry was only a slightly premium price. The learning curve was extremely low, the interface crazy intuitive, and it never crashed!

When clients asked what kind of computer I used I was always excited to tell them about Apple. I would usually say something like, “I fix computers all day everyday, I use an Apple at home because it just works.”

Fast forward nine years and I am absolutely convinced that Steve Jobs and what he built at Apple were and are the single most important influences on my technological life and career.

I am now a software developer, using my Mac and iPhone every day for fun, work, communication, and so much more. I can’t imagine I would have ever accomplished so much in the last nine years if it weren’t for Apple.

I just finished reading iWoz and I’m really looking forward to reading Jobs’s biography.

I owe a debt of gratitude to Steve. My thoughts and prayers go out to his friends and family.

The History of Speaker Deck

2011-10-03T00:00:00Z

How a product was born, from inception to implementation, and distractions to launch.

Inception

Speaker Deck was born in a little Irish bar right around the corner from our offices in South Bend Indiana in May of

I was meeting Steve and John for lunch and they were talking about how much they disliked the slide sharing options currently available. It was of special interest to them as they do a lot of public speaking and at the time were teaching classes at Notre Dame.

They were dreaming (as they do) of a better way to share presentations with the world. Something elegant, simple, without all the mess. Then reality hit and they realized they just didn’t have the time to build it. Life was too busy, family, client work, teaching, and Harmony ate up all their time, there was just no way they could start working on a new product.

Implementation

This was my opportunity. If I was serious about my dream of becoming a programmer, here was my chance. I said “I’ll do it”, then cracked open my laptop and started hacking around with ghostscript and imagemagick to see if I could extract images from pdf’s. An hour later the core tech (now extracted into a rubygem) behind Speaker Deck was working (in a limited fashion) and a product was born.

June 1st of 2010 was my first git commit, a basic rails app with an already processed presentation so I had images to use as I created the html and css from Steve’s initial mockups. It quickly took on a life of its own at that point, Steve implementing an awesome embeddable slide viewer, so nifty we actually use it on Speaker Deck the same exact way you use it when embedding a presentation on your own site.

The guys taught me test driven development while building Speaker Deck, and over the summer and into the fall I kept working on it. Initially just Steve and John were using it to host their slides, but then an opportunity arose while at Mongo Chicago, and on October 20th of 2010 we had our first beta testers signup and upload presentations!

(my coworker/boss John presenting at Mongo Chicago 2010)

Good Distractions

Almost a year has passed since we started signing up our first beta users and September 26th we launched Speaker Deck to the world! In the past year I ended up going to work for Steve and John and they also hired Brandon Keepers and Matt Graham. In that time our team has been doing a lot of consulting work, making our existing product Harmony better, and we even launched Gauges, a website analytics service.

The entire time we were working on these other projects we were formulating what we wanted Speaker Deck to be and this summer that plan started to solidify and we got back to work on it. The first big thing that needed to happen was moving Speaker Deck to Heroku and S3 for hosting.

This transition only took a few days to initially implement but gave us an easy & affordable way to grow the service into the future. Meanwhile Steve went to town on some UI & UX improvements that would help set us apart from the competition even more.

Launch

The last month leading up to launch was pretty intense, hammering out final details and deciding that we wanted to release the product to our users as a free service.

Then on September 26th we launched it at about 3pm EST. That first day we had over 600 signups and hundreds of presentations were uploaded. It was a rush seeing people use it, getting feedback, fixing bugs, and dreaming about the future.

In the past week since launch we’ve had many more signups, hundreds more presentations uploaded, and such great feedback that has helped us formulate an even better plan for how to move forward.

I’ll be posting more about Speaker Deck later this week, talking about some of the triumphs and struggles we’ve had since launch.

Just Write It Down

2011-10-03T00:00:00Z

I struggle with remembering great ideas, not so great ideas, things I want to accomplish, and so much more. Let’s talk about the easiest way to hack our lives so we can be more productive.

If you find yourself struggling to remember conversations, epiphanies, and just “what should I do next” then you may be struggling with the same thing I am, a lousy memory.

For years I’ve told people my memory is horrible, but for some reason I never actually took action to rectify the situation! Maybe I was lying to myself and saying “oh, you’ll remember that” or maybe I never made the connection that my memory will never get better without being proactive.

Today that is changing. Actually, this pattern of figuring things out and then forgetting the solution has been going away slowly yet surely for me for a few months now. How you ask?

My coworker John (@jnunemaker) has been encouraging me since I started working with him to write things down. Keep a small notebook with you at all times, record important points from conversations, ideas you have in the middle of doing other things, any little piece of information that might actually be useful in the future.

Apparently I’m a slow learner as it has taken months to get into the habit of writing things down, but now I’m seeing real improvements in my memory. I don’t even have to read over all of the notes I’ve taken to remember things sometimes. Just the act of writing it down in the first place is helping me create long term storage for that information in my brain.

I’m working on a lot of little processes in my life to improve my productivity, both at work and at home. Remembering things has been a great first step and I’ve been blessed by the results.

Grim

2011-09-06T00:00:00Z

Grim is a simple gem for extracting (reaping) a page from a pdf and converting it to an image as well as extract the text from the page as a string.

Grim is my first Ruby gem! Not technically my first OSS contribution, but definitely my first gem. This project came out of Speaker Deck and is used by Speaker Deck whenever you upload a presentation.

Sample usage

pdf = Grim.reap("/path/to/pdf")
count = pdf.count
pdf[3].save('/path/to/image.png')
text = pdf[3].text

pdf.each do |page|
  puts page.text
end

This gem is perfect for anyone working with PDF’s that wants to extract single pages as images or the text from a page using Ruby.

Enjoy!

Ditch Your Crew

2011-09-03T00:00:00Z

Want to be a better programmer and a better person? Ditch your coworkers, go out and meet other peers, ask questions, and most importantly, listen.

What the heck am I talking about? A little back story is in order.

Rocky Mountain Ruby conference was this last week and I had the opportunity to attend thanks to a ticket I won on twitter (thank you @bittheory_) and the company I work for being generous enough to pay most of my way.

I attended it without my usual crew and only knew a couple people at the conference, so pretty much as soon as I arrived, making new friends was a necessity. Thankfully I’m not a shy person, so I set about meeting everyone I possibly could.

Not being surrounded by folks I already know and have been learning from the past few years, not being in my comfort zone, gave me the opportunity to start completely new conversations. This is invaluable if we want to keep pushing ourselves to learn and become better people. I learned more during the three days at this conference than I have the last three months.

My title and intro were strong words (link bait!) but my point is this. Whether you are out with your coworkers or on your own, be deliberate about getting outside your comfort zone, meeting new people, building new relationships, asking lots of questions, and listening to the answers.

You will not be disappointed and the world will be a better place for it.

A waiter once taught me

2011-08-04T00:00:00Z

While in San Francisco on our long overdue honeymoon I learned a valuable lesson from our waiter at the Farallon restaurant. While the food was amazing, his confidence and pride in their product was the thing that intrigued me.

People Expect Great Service

I expect great service anywhere I go, probably because it’s something I strive for in my vocation. But sometimes people surprise me and most of the time it’s a good surprise.

One of the hardest customer service jobs I can imagine is serving at a restaurant. I know I couldn’t do it, having to be courteous every second of every diner’s meal, remembering every detail of their order, and finding the perfect balance of when to check up on a table and when to leave it alone.

Our server was amazing—his timing, menu advice, and interest in our wellbeing set him apart. But the thing I really came away with?

Confidence and Pride

He had complete confidence, and pride, in the food that they serve. He was glowing with pride when giving recommendations, and absolutely confident that their best was better than anything we could eat anywhere else.

Not once did he walk up to our table when we were in the middle of a bite, and when he did stop by it wasn’t to ask “is everything ok?” but rather to ask “so what did you think?”

Asking the Wrong Question

I never realized until then that asking someone “is everything ok?” while they are consuming your product, is just about the worst thing you could ask. Why?

First, it prompts a yes or no response, so in that moment they have to decide whether they like or dislike it more. Why give them a chance to form an opinion based on a 50/50 split?

Second, it conjures this notion that you don’t have supreme confidence in the product you are selling, that there is the possibility you don’t think it’s good enough.

Asking the Right Question at the Right Time

Instead, we should be interacting with our customers in a way that shows we are confident in what we are selling and we take pride in the quality of the product.

When the waiter asked me “so what do you think?” he was requiring me to think about the tastes, the smells, the pairings of ingredients, and I immediately had good thoughts and told him so. In addition, he timed his question so well that it came at a moment where I could stop and think and answer clearly. My mouth wasn’t full and I wasn’t distracted by taking a sip of my wine.

He listened to my answers and agreed and then would often say, “if you thought that was great, wait and see what I’m bringing you next.” It never failed either—each new course was even better than the previous.

Making This Work in Any Business

This post is a call to action for us to think before we interact with our customers. How can we convey our confidence and pride in our product and how can we better time our questions to the customer so that they can give us valuable feedback and we can bring them the “next course” with the maximum effect.

Speaker Deck's Technology Stack

2011-07-29T00:00:00Z

Ever curious about what the software stack for programs you use looks like? I am, so I thought I’d share what Speaker Deck’s technology stack looks like right now, and then I can look back a year from now and see how much it has changed.

Speaker Deck is a simple application. You upload a PDF of a presentation that has been exported from Keynote, PowerPoint, or something similar, and it turns it into a deck of images that are easily viewed through an HTML5 slide browser.

High-Level

So what makes it tick? Here’s the rundown from a high level:

html/css/javascript: currently we don’t use Flash anywhere
Ruby on Rails web framework
A bunch of ruby gems which I’ll list below
MongoDB, a high-performance document-oriented database
Redis, an advanced key-value store
FOG, technically a ruby gem, which gets its own section below, but had to mention it here as it makes storing files in the cloud super easy

Service Providers

Platform as a service and software as a service providers:

Heroku is a platform for easily and quickly deploying, hosting, and scaling applications built on Ruby, Node.js, and now Clojure. A simple “git push heroku” lets us deploy to the cloud.
MongoHQ is where we host our MongoDB database. They manage the servers so we don’t have to.
Redis To Go is a hosted Redis database solution. We use Redis for job queues and Redis To Go lets us quickly scale our database to meet our needs at the time.
Amazon Simple Storage Service, otherwise known as Amazon S3, is a quick and easy way for us to host thousands of slides and PDFs without going broke. They charge by the gigabyte for bandwidth and storage and it’s darn cheap.

Ruby Gems

There are a few more pieces of software we use for testing but this post is already getting kind of long.

So what are you using in your software stack?

Compiling Executables on Heroku

2011-07-28T00:00:00Z

Are you using Heroku and want to run a program not included in the Heroku environment? I’m going to show you how.

For Speaker Deck we wanted to be able to extract the text from uploaded pdf’s so that we can index them and make them searchable, but the program we’d been using to do this on our dev machines, pdftotext (part of the XPDF library), wasn’t available on our Heroku instances.

On a whim I typed “heroku run bash” and sure enough I was dropped into a bash shell with our Heroku Cedar Stack instance.

heroku run bash

Then I went into our app’s tmp directory and tried a wget with the xpdf url, but it failed so I tried curl with the -o option to output to file and it worked. Then I unzipped the file and started building it!

curl ftp://ftp.foolabs.com/pub/xpdf/xpdf-3.02.tar.gz -o xpdf.tar.gz
tar zxvf xpdf.tar.gz
cd xpdf-3.02
./configure
make

When it was done building I found the executable we needed, pdftotext, sitting in the xpdf build directory. I scp’d it to my machine, created a bin directory in our app’s folder, and stuck the executable there. Then with a quick git commit and git push to Heroku we were in business!

If I had an environment locally that was identical to the Heroku instance I could have built it locally, but to ensure it was built to run on the Heroku instance it just made sense to build it there in the first place.

The bin directory was added to the app’s path automatically so I was able to execute the pdftotext program from inside our Rails app without a hitch.

Update: Josh Peek commented on the Hacker News post that he bundled the xpdf source in a gem which compiles itself at runtime… Probably a better longterm solution as it works if the underlying environment changes enough to break a prebuilt binary.

Moving Speaker Deck to Heroku

2011-07-27T00:00:00Z

While at RailsConf earlier this year we decided that it would be wise to move Speaker Deck to Heroku and S3, and we finally made it happen.

History

Speaker Deck has been my labor of love since June 1st of last year. Steve and John had the idea and I set about making it happen in my spare time. It launched October 20th 2010 (with a lot of help from Steve and John) and has been purring along quietly since then. We’ve had 38 people request beta signups and as of today 85 presentations have been uploaded.

Getting Started

So back to point of this post, we decided that this app, with its hunger for lots of background workers (to process slides) and its desire to scale as adoption grows, mandated that we figure out a scaling strategy that worked for the app, and worked for us and our resources at the moment.

We had been tossing Heroku around in the back of our minds for awhile and after talking to a couple of the Heroku guys at RailsConf and having them check if their system had some software we needed (imagemagick/ghostscript), we decided to give it a go.

Just a few days ago I decided to get to work on it after talking to my coworkers about how to make it happen. Brandon and I dug in and implemented storing slides on S3 (instead of MongoDB’s gridfs) in just a few short hours thanks to the Carrierwave gem.

It just so happened that this weekend was the Rails 3.1 hackfest, so Saturday we upgraded the app to Rails 3.1 and then to use Ruby 1.9.2 so it could run on the Heroku Cedar Stack. Next we started working on deploying to Heroku.

Deploying

Deploying ended up being a lot of trial and error. First I ran into an issue with Heroku’s bundler version (a release candidate) not being able to find one of my dependencies, but that was solved with the handy “bundle cache” command. You just do bundle cache and then check vendor/cache into your repo and it sends all the gems up (still in the compressed gem form) so bundler can install them from the vendor/cache dir.

Finally I couldn’t get my resque workers to run in the right environment, turns out I was missing task 'resque:setup' => :environment in my Rakefile. Hadn’t needed that on our previous deploy to Linode, so it took awhile for me figure that one out.

Migrating

Brandon and I wrote a script to migrate the data on the old Linode server to our local database and at the same time suck the pdf’s out of Mongo on the old server and then put them on S3 rather than keeping them in gridfs. Then a quick mongodump and mongorestore later our production data was synced from my local machine to our new MongoHQ database.

Now that the pdf’s were on S3 and the mongo database was populated we just had to reprocess the pdf’s into slides. Technically we could have grabbed the already generated slides from the old server, but we really wanted to see how much we could scale our worker processes on Heroku.

Here’s the fun part! After a few failed starts (I’ll talk about those in a minute) we had 100 heroku workers processing 5000 slides (an intensive imagemagick/ghostscript task) and it ripped thru them all in just a few minutes. It was awesome to watch the resque web console and typing heroku ps:scale worker=100 was a lot of fun!

Heroku Scaling Gotchya’s

DO NOT remove workers while you are processing a bunch of stuff unless your jobs are easy to restart. Heroku kills the processes not caring if they were already working on something, leaving jobs in limbo 😕

DO NOT change (upgrade/downgrade) your RedisToGo plan while workers are running, your redis db gets replaced instantly, losing any currently processing jobs.

Wrap Up

Overall this was a fairly painless move and it was so exciting to scale up our background workers and watch 20 slides a second get processed. Now that Speaker Deck is on Heroku and S3 we have one less constraint holding us back from releasing new features and hopefully leaving beta soon.

The Best Work Days

2011-07-01T00:00:00Z

Today was an awesome day at work.

One of my favorite kind of work days is when we’re all working on different things, we’re all in the zone, and we’re all in the same room. Today was one of those days with Steve, John, and I all hacking on new features for our products.

Every hour or two one of us would leave our keyboard and gather the others to show what we’d got done and take input from the other two. Then the others would take their turns in the spotlight.

For me at least this routine throughout the day kept me pumped up and excited about my progress and pushed me to make even more headway.

I’m pretty psyched about what each of us are working on and I’m really excited to show you soon!

Starting to Unplug

2011-06-30T00:00:00Z

Changing the way you live your life sounds weird, and drastic, but I have to admit that I’m really starting to enjoy it.

I have been constantly connected to everyone I know, via my cell phone and the internet, for over a decade and a half now, except for a few rare occasions (like my wedding) where I left the cell phone behind.

It has always frustrated me that my wife often won’t reply to emails for weeks, never cared to hang out on twitter, was never interested in reading my blog, and basically has never made modern communication (even her cell phone, she rarely answers it) an important part of her daily routine. But she seems perfectly happy and a lot of the time less stressed than myself, so I decided to re-evaluate how I use these tools to see if I’m doing it wrong.

Since I left my job at SabreTech the first big change I made was leaving my phone on silent all day, everyday, unless I’m expecting a call that I really want to get. The iPhone still vibrates, so if it’s in my pocket or next to my hands on my desk I’ll notice it ringing, and most of the time I’ll pick it up. But not worrying about getting every call is a better way to live, trust me.

Next up was not hovering over twitter every second of the day. I still open it three or four times at work and a half a dozen times in the evening, but it’s not open all the time anymore, with its little icon constantly distracting me that there are new tweets waiting to be read. Another source of anxiety lifted.

A new source of anxiety introduced itself last year when I started playing Words with Friends. I quickly learned that I would go insane if I didn’t turn off the notifications it sends you every time someone you’re playing against takes their turn. Later I learned how to turn off the badge notification telling me how many games were waiting on me.

But the biggest change I’ve made to date was two weeks ago when I turned off push email on my iPhone. In fact, unless I open my mail app it NEVER goes out and checks for new mail. Now I check my mail in the morning when I get up, keep my mail client open during the day for work, and then don’t look at it again until the next morning. This has been a huge change, for two reasons.

First, I’m not constantly distracted while spending time with my friends and family. They get more of my attention, which makes them happier.

Second, I’m not constantly being reminded of work and what I have to do the next day. I can actually spend time enjoying life outside of work, I can stop obsessing on silly things, and I can just enjoy all of God’s blessings.

Try it, but let me warn you, you’ll probably like it 😃

Obsession and Understanding

2011-06-29T00:00:00Z

I’ve been emotionally up and down a lot the past few months and a lot of it has had to do with work. Don’t get me wrong, I love my job, and therein lies the problem.

I’ve always been very passionate about my work, but as I get older and learn more about life, I’m realizing I need to put things into better perspective.

Obsessing about one area of your life is unhealthy. Religion, politics, work, hobbies, or family; obsessing over any of these can lead to anxiety, stress, and dissatisfaction with life.

God has been teaching me lately that I need to put my hope in Him, that I need to understand my joy will never come directly from any of those areas of life I mentioned above, but that it can come from recognizing His work in my life in all of those arenas.

Right now I need to stop obsessing on what I want out of my job, and start understanding how I’m learning and growing in my job.

Thank you

2011-06-08T00:00:00Z

Recognizing someone’s hard work and thanking them for it is always worth it.

I’m in Dallas right now on business and one of the nice things about the place I’m staying at is they always give you a tray of three chocolates on your bed when you first arrive.

Well, I ate my three chocolates within 48 hours of arriving and this morning all I could think about was having another one. So selfishly I began to compose a message on the notepad next to my bed asking for more.

While writing the little note to the person who cleans the room I began to think how awesome it was that they actually took the time to do it, making my bed, replacing the towels, emptying the trash, and who knows what else.

So I ended up writing a note to them thanking them for their hard work and politely asking if it was possible for me to get another chocolate. I even made a little papier-mache flower out of one of the used chocolate wrappers.

When I got back to my room later in the day the tray was on the bed with five, YES, FIVE, chocolates!

Moral of the story? Think about what others do for you, even if it is their job, and thank them for it. They will appreciate it and you’ll get chocolate (ok, so maybe not all the time).

The Smoker - Back Story and First Day

2011-05-12T00:00:00Z

I’ve been planning on building a 55 gallon smoker for almost a year and a half now, but the time and resources just haven’t been there. Today marked the first day of real progress!

It all started when this blog post appeared a year and a half ago. I saw it and I immediately fell in love. I’d only been smoking for a few months at that point, with a $35 Brinkman, but I’d already developed a passion for good BBQ.

In the spring of 2010 I jumped on Craigslist and found a couple of barrels only 2 miles from my house, and immediately bought them. But then, as often happens to me, I set the dream of building it aside because of fear of starting and my many excuses like lack of tools, lack of time, etc.

But the dream persisted, and when I found out my parents would be returning from Argentina for a few months this summer I decided to enlist my dad’s help and get this thing rockin!

A week ago we set today as the day to begin, which left me just a few days to prepare. Preparation meant getting a jigsaw, a welder, and this curve pattern printed to scale. I decided the building would need to be broken into phases, for financial and time reasons, so this first day I limited to just needing the jigsaw and curve pattern.

Buying a jigsaw, easy. Printing a 70” curve, not as easy 😕

The story of acquiring the curve requires some back story. Again, I’ve been planning on building this thing for over a year, so I actually started searching out a plotter to print it a year ago. At the time I worked at SabreTech and we had quite a few industrial clients with printers, but I never managed to find the right place to get it done.

One day seven or eight months ago while visiting my college friend Bob at his workplace Daavlin (also one of our best clients) I noticed they had a plotter. Bob proceeded to explain that they’d just acquired it, but hadn’t figured out way to hook it up yet (older interface that none of their computers had). I offered to help (I think) in exchange for printing the curve, but he said he’d get it running and told me he’d print the curve anyways.

Fast forward to yesterday morning (seven+ months later). I left for work thinking that I’d need to find a way to print that curve. I got halfway to work and realized I’d forgotten my lunch, so I turned around and went back home. As I pulled in the driveway I noticed a package on the front step. I grabbed it, ran inside, cut open the package, and lo and behold there was my curve printed to scale! Somehow Bob managed to time printing and sending it to me so perfectly that it arrived the day I was going to print it myself. Awesome.

So today I went and grabbed a jigsaw, some blades for cutting metal, and dad and I got to work this evening. We focused just on the cutting phase, and knocked it out in short order! Here are some pics for your enjoyment 😃 Sorry, forgot to wear a shirt in a few 😕

Priorities

2011-03-05T00:00:00Z

Balancing your home and work life can be terribly difficult, especially when you love your job.

Shut It Off

Last night my wife and I went on a date, first out to dinner and then to grab a movie to watch at home. Once back home she was getting ready to watch the movie while I popped the DVD in and queued it up.

I popped open my laptop and noticed our work chat had been blowing up and instantly got sucked in. My coworkers were hacking on Gaug.es and doing some awesome stuff with async and EventMachine and I immediately wanted to be a part of it.

Instead I closed my laptop just in time to see my wife coming into the living room ready to watch the movie. This wasn’t an easy decision, but it was the right decision, one I haven’t made hundreds of times in the past, to the detriment of our relationship.

Spending time with your loved ones (in my case my wife and dogs) must take priority over your work life. What kind of message do you send to them if you always leave that laptop open? Not that you are dedicated, or that you are providing for them, you are sending the message that you care more about work than you care about them. They don’t get over this easily, trust me.

I’m not saying you can’t work at home or in the evenings, I’m saying that it’s important to set aside and dedicate the majority of your home life to spending time with and sharing your life with those you love.

Dream At Home

One of the reasons it has been so easy for me to make the wrong decision in the past, to work late every night, is that I love my work, I’m excited about it, and often that excitement feels greater than anything I’m excited about at home.

It has been important for my wife and I to find things that we’re both excited about, which in our case is food and travel, and spend time talking about or doing those things every day. We spend anywhere from one to three hours in the kitchen every night, cooking, sharing stories from our day, sharing our dreams and just being best friends. No computers (except to play some music), no hacking, just spending quality time together enjoying each other’s company.

Exceptions to the Rule

Having said all that, I still choose to work late two or three evenings every week. I feel like (and my wife agrees) that it is hard to get ahead in life, hard to take things to the next level, if you don’t kick it up a notch every once in awhile.

My wife and I don’t plan on living in Elkhart, Indiana the rest of our lives, we dream of moving to Italy, so we feel like burning the midnight oil a couple nights a week to make that dream happen sooner is totally worth it.

The last thing I would caution on working at home is that you prepare for it, warn those who may depend on you so they can plan accordingly. I also try and pitch in a little extra effort that day, making sure chores are done, whatever I can do so she doesn’t feel like she’s on her own.

P.S. I had no idea it was the National Day of Unplugging when I wrote this.

Share the Dream

2011-03-03T00:00:00Z

Sharing in the vision and energy of your team is a key factor to success and happiness at work.

Putting Your Dreams On Hold

When I started at OrderedList there was one product I was really passionate about because I had done most of the work on it. I quickly realized though that I needed to put that passion on hold, or better said, redirect it towards Harmony, so that I could help push the vision of my team forward. I needed to share their dreams and hopefully incorporate mine at some point.

As soon as I dug into Harmony, fixing weak spots in the test suite, spearheading the move to Rails 3, working on a new feature (that I’m dying to tell you about), my heart began to change, my passion became their passion, and I was happy again and part of the team.

Almost as soon as I really started getting passionate about Harmony John came home from sick leave and had this crazy idea to build a web analytics service, which we now call Gauges. At first all I could think was, boring, but hanging around Steve, John, and Brandon I started to catch the buzz, the energy, and the excitement!

This is when I began to realize that I didn’t necessarily have to put my dreams on hold, I just needed to share in my team’s excitement and get them excited about what I’m excited about by letting them see my own energy.

Every team is different, but letting your coworkers see your excitement and passion about a product/project and sharing in their dreams at the same time is one easy way to stay happy at work and be excited to go to the office every day.

New Guy Blues

2011-03-02T00:00:00Z

Being the new guy in your workplace can be intimidating. It can cause anxiety, frustration, and hamper your productivity. Sometimes it’s your coworkers not making it easy for you, sometimes it’s just you, your mindset, willingness to stretch your limits.

I’m one of the new guys at OrderedList and I’d like to share three things that helped me jumpstart my productivity at OrderedList and catapult me to being a key part of the team.

Servants Heart

This is something we should all apply, regardless of whether we’re the new guy, but it’s especially helpful when trying to fit into a new environment. Having a servant’s heart means you are constantly looking for the best way to serve those around you.

You notice someone has a stuffy nose, grab them some kleenex. A coworker is frustrated with what he’s working on, ask him if he’d like to use you as a sounding board.

Being aware of others’ needs and acting on it makes you instantly useful to the team and endears you to them.

Find A Mentor

Starting a new job means learning how to do new things. Some people can just jump in without help and do an amazing job; I’m not one of those people. I found at this job that watching, recognizing, and imitating patterns of work was the quickest way for me to get directly involved in what we do.

Thankfully I have the opportunity almost every day to pair program with our other new guy, Brandon, who has years more experience than I do. I do the best I can as a pair partner, catching typos, helping with decisions, and more, but most importantly I’m watching every line of code he writes, understanding it, and asking questions when I don’t, so that later I can imitate and create beautiful code.

I could just dive in on projects and do things the way I know how to do them, but finding someone smarter than you to imitate pushes you to continue expanding what you know how to do.

Do What You Know

The past month and a few days we’ve been working on a new product, Gauges, in our spare time. A lot of the tech on this project I had never used before, so initially I found it hard to jump in and help. I paired and helped when I could, but I really wanted to contribute on my own. Then the opportunity arose to work on the admin section, something I knew how to do.

I dove right in, here was something I could contribute with little to no help from my team, and it was something that they could appreciate day to day. Sometimes you need to step back, do what you know, and get that instant rush of being a valuable member on the team, a contributor, and not so much the new guy anymore.

A WebDev's notes on native Android/iPhone app development

2010-11-26T00:00:00Z

I was contracted to build a fairly simple phototherapy treatment time calculator app for one of our clients recently, and in the process learned A LOT about developing for the iPhone and Android using html/css/javascript.

The requirements for the job were that the final app feel native and that it be able to be purchased on the respective market place (Appstore or Android Market).

I’d already written the app once for the iPhone, using the jqTouch library and then wrapping the whole thing with PhoneGap, but this time around the client wanted to add some features that made me look further than jqTouch.

Initially I fantasized about a write once deploy twice approach using something like Appcelerator Titanium. The more I read however the more I realized no matter how I went about this project I was going to end up with more than one codebase, one for the iPhone and at least one for the Android. I decided to go ahead with Appcelerator however and developed for the iPhone first. One of the biggest things I was looking for was a native bottom tab bar for navigating between the different phototherapy calculators (UVB, UVA, UVA1, and Blue), and Appcelerator let me quickly build a native, beautiful, functional app that exactly fit the clients needs.

After a bit of troubleshooting I had it deploying to my actual iPhone, but no matter how hard I tried I could never manage to get it to deploy to the Android emulator.

Next I started working on a Sencha Touch version of the app, which I planned to wrap with PhoneGap, but after about an hour of digging around in Sencha I decided it didn’t fit my programming aesthetic. I also talked to someone who wrote an app in Sencha and they said it had a ways to go with speed, animations were still jerky on older hardware.

Finally I decided to give JqueryMobile a try (thanx Xian!) and it was a great fit for a webdev like me. Using the latest PhoneGap and JqueryMobile I had the app rewritten and running on the Android Emulator in just under 2 hours, and then another 2 hours tweaking the interface and interactions. If you know html/css/javascript, you can write a fairly native feeling app in no time with JqueryMobile.

Having used jqTouch, Appcelerator, JqueryMobile, PhoneGap, and having looked at Sencha, I have to say Appcelerator was by far the best experience. I enjoyed programming the interface rather than laying out the html and then styling it with CSS. I enjoyed how quickly and easy it was to deploy to the iPhone (I wish it could do the same for Android!). Most of all I loved how it built a native interface, which beats an html5 interface almost every time in my opinion.

What laptop to get?

2010-11-20T00:00:00Z

As you know I’m taking a new job. New job means new laptop, and I’m having a terrible time deciding what Mac to get. Just browsing Apple’s website I fell in love with the new 13” Macbook Air, but the feedback on Twitter has been 50/50 for/against. Some think it works just fine as a development machine, especially with the rockin’ SSD and 4GB of RAM, but others worry that going from MBP to the Air will leave you wanting.

I’ve been using a 15” 2.53 GHz Core 2 Duo Macbook Pro with 4GB of RAM for a few months now, and even it is not fast enough for me (looks like it’s the HDD that’s the bottleneck most of the time though).

I figured I needed some hands on, so I stopped by our new Apple store in Mishawaka today and played with several different models.

11” Macbook Air: this thing is tiny. I liked it except for the giant surround around the screen, it makes the screen look way too small. Give me a 1/2 to 3/4 bezel, not an inch and a quarter!

13” Macbook Air: wow is she pretty, but it would definitely take some getting used to. It has the same number of pixels as my 15” but crammed into a 13” screen. I do love the weight to size ratio though. I couldn’t really run any speed tests, but the thing was dang fast from what I could tell.

15” Macbook Pro: I tried out one of the i5’s with 8GB of RAM and an SSD and it was screaming. The only downside is the thickness/weight.

My conclusion at this moment in time is that Apple needs to make me a 15” Macbook Air! I don’t need an optical drive, I want tons of pixels, but I also want that bigger 15” screen. Imagine a 15” with an i5 processor, still super thin, and a 10 hour battery, all weighing under 4 pounds. I say hot hot hot…

I know it’s a pipe dream, but hey, boys gotta dream sometimes right?

I’d love to hear from anyone using the new Macbook Air, what has your experience been?

Hey mom, I got a job!

2010-11-18T00:00:00Z

How a butler was born.

Well folks, 2010 has been quite a year. Three of my close friends got married, my lil’sis is getting married next month, my best friend is having a baby, and I have decided to leave SabreTech and take a job at OrderedList.

Woh! Wait a second Jon, aren’t you part owner in SabreTech? Indeed I am, but with the news of my departure my business partners have decided to buy me out.

So how did I get to where I’m at now?

First I’d like to take a quick look back. I bought SabreTech in 2005 with Brad Cochran and together we turned it into a profitable and growing business. In 2007 Sam Sallows joined the team and we made him a partner in a little over a year. SabreTech has been growing since we bought it, but the addition of Sam really made things go crazy. SabreTech has grown 400% in 5 years and the rate of growth is increasing.

After my wife and I moved to Indiana in 2007 with the hopes of expanding SabreTech, it quickly became apparent that the economy in Elkhart couldn’t support a second store. To make up for my down time in Indiana I started to really apply myself at software development, learning everything I could. That love of programming took me to a little group that met monthly at Notre Dame to talk about programming (specifically about using Ruby and Rails). At that meeting I met Steve Smith and John Nunemaker.

Steve had left Notre Dame to start OrderedList and shortly after I met them John left Notre Dame to join Steve. Over the past couple of years we started to hang out more during work hours (meeting in coffee shops and eventually at their office) and after hours (Notre Dame tailgates, the Super Bowl).

Apparently John and Steve saw something in me that they liked, because they offered me a job, and yesterday my wife and I decided to take it.

That brings us to today, two weeks and one day before my last day of work at SabreTech. I start at OrderedList on December 6th! I’ll be handling customer support for their product Harmony, as well as programming on various projects from SpeakerDeck to client work.

This will be the first time in 10 years that I haven’t been a business owner and have an actual boss (already practicing my “yes boss”). I’m sure it will be an adjustment, but I honestly look forward to having less stress, better hours, and a 20 minute commute (as opposed to 90).

I’m crazy excited to be working with Steve and John, they are two of the smartest people I know, and both love to teach and push their peers to the limit. I’m going to be in an environment where constantly learning new things is a necessity, not just an aspiration.

So yeah, mom, I went and got a job 😉

UPDATE: Read the announcement over on the OrderedList blog.

Vacation Reviews

2010-09-30T00:00:00Z

We’re just now back from a great trip to Boston MA, Concord NH, and Milton VT. From trying oysters to a tasting at a winery, our foodie passions drove us to try new things. We made sure to post our reviews on Yelp when we returned home!

In addition to eating our hearts out, I’d also like to mention the amazing place we stayed.

We definitely love traveling, and this particular trip fulfilled many a dream!

46 Monument Avenue

2010-09-30T00:00:00Z

This summer my wife and I planned a trip to Boston for our best friend’s wedding. While getting ready to book a room I came across an article about airbnb.com, so I decided to give it a try. The first 3 attempts to get a room failed, but each time Airbnb sent me a better coupon so I kept trying. The fourth attempt got me 46 Monument Avenue, and it was the best purchase I’ve made in a year.

For a very reasonable price ($100 per night) we got a cute studio apartment with a private patio, in Charlestown, just a short distance from the North Side.

The host, Atef Aziz, emailed us before arrival to find out more about us. He was helpful enough to get us into the room at 10am on our check-in day, rather than having to wait until 3 or 4pm (like most hotels). He was eager to help in any way, from walking or driving directions, to restaurant recommendations.

The apartment is adorable, a studio apartment with a nice large bathroom and stand-up shower. It had a functional kitchen (larger than our kitchen at home), washer/dryer, TV with basic channels, Wi-Fi internet, and an amazing little patio. The patio has a fountain with goldfish, a table with umbrella and chairs, a charcoal grill (the only way to grill), and lots of flowers and fauna. The apartment was only a 10-minute walk to the North Side of Boston and an 8-minute walk to the T (orange line).

The shower was initially not as hot as I like my showers, but a quick email to Atef got that fixed. The apartment was small, but open, and the kitchen entirely usable. The first night it was a bit warm, so I mentioned it to Atef and he got us a fan, which fixed the problem. The patio was perfect for relaxing in the morning, hanging out during the day, and winding down at night.

I can’t recommend 46 Monument Avenue and Atef Aziz enough. From his hospitality to the beautifully furnished accommodations, this stay in Boston was a delight.

See more about his rental here.

The Death of Free

2010-09-09T00:00:00Z

I’m predicting the death of free in the next one or two years. You heard it here first.

What the heck am I talking about? It used to be in our house that we only used services on the internet that were free, flickr, delicious, youtube, clearcheckbook, etc. In the past two years we have shifted to using Flickr Pro, Pinboard, Vimeo Pro, ClearCheckBook Pro, Rdio, and Netflix streaming, just to name a few.

Not only have we upgraded to the pro version of almost every internet service we use, but we also usually don’t start using a new service unless it has a paid version. Why? There are two primary reasons:

Companies charging money for their service are more likely to be around in 5 years.
I’m more likely to use a service if I’m paying for it.

The second reason is more interesting. It helps me weed out things in my life that are wasting my time. If I’m not willing to pay for something to use it, it most likely isn’t worthy of me spending any time to use it.

I think my generation (and my gen’s kids) are finally starting to take to heart the old saying “you get what you pay for”. Free stuff is for the most part crap, has strings attached, and ends up being a time sink.

The Freemium model still works, but I think its on the way out. The model that makes more sense to me is either just a great demo & paid service, or a free trial that pushes to paid.

Of course the irony of this post is I’m not paying for Tumblr, and I can’t seem to find anywhere where I can give them money. However, I am choosing Tumblr as my micro-blogging platform over Posterous because I think they are more likely to have a paid version in the future.

Make Asterisk use Gmail for emailing faxes

2009-09-10T00:00:00Z

While Asterisk provides a simple way to replace sendmail when sending voicemails, the incoming fax portion of Asterisk is not so easily reconfigured. By studying how it handled an incoming fax from the Asterisk CLI I was able to find this perl script: /var/lib/asterisk/bin/fax-process.pl.

This script uses Net::SMTP to send its faxes as attachments via email. We (and by we I mean Daniel) rewired the perl script to use Net::SMTP::SSL instead and made it work with gmail!

There were a few libraries I had to install via cpan:

force install F/FL/FLORA/Net_SSLeay.pm-1.30.tar.gz
install S/SU/SULLR/IO-Socket-SSL-1.30.tar.gz
install GBARR/Authen-SASL-2.12.tar.gz
install C/CW/CWEST/Net-SMTP-SSL-1.01.tar.gz

And finally here is the rewritten script! http://gist.github.com/184654

BarCampGR

2009-08-22T00:00:00Z

Just wanted to post a little something while I’m still here at BarCampGR, an attendee driven conference. Its been great fun, as you can see from the many posts to twitter…

Note to those who attended my talk on smoking meats, here are some great links:

Amazing Ribs is the definitive place to learn about smoking ribs. Look at the page about Texas Crutch to find the perfect cooking method.
this chicken recipe is amazing, just make sure you cut down the salt they use in the brine, AND the rub, by half, or it will be way too salty.
kind of off topic, but this was a great recipe, even if it had nothing to do with smoking 😃
wanna see my original rig? check it out

Subscribe to my rss feed, or at least follow me on twitter, if you are interested in smoking, or cooking in general. Oh yeah, I post about tech too.

…nuf said

Best phone system for a small business, Part 1

2009-08-16T00:00:00Z

This article is for small business owners, and even better, for their IT guy/gal… If you are looking at upgrading your phone system, and want to upgrade inexpensively but have a clear upgrade path for the future, I’m going to outline how to build what I believe to be the most cost effective, easy to maintain, pbx based phone system available.

The pbx itself is based on PC hardware, with a special card for interfacing with the telco (ATT, Verizon, etc), and a software stack called PBX in a Flash. PBX in a Flash (PiaF) was put together by a few gentlemen looking for a solid software stack for their telephony needs. Here is what is in the stack:

CentOS for the OS that everything lies on top of.
Asterisk for the PBX stack.
FreePBX helps in configuring and maintaining the Asterisk configuration.
Prebuilt scripts, for configuring everything from dhcp to cisco phones

For phone hardware I’ve used Cisco, Linksys, and Aastra. Aastra seems to be the recommended brand of late, for features, price, and ease of configuration. I’m not a huge fan of the Cisco phones (overpriced and they seem to cripple their SIP firmware), but Cisco’s economical product line, Linksys, makes some great phones.

Well, there’s the intro for you, if you want to learn more, read on!

I’ve done phone systems for businesses that only need 2 or 3 phones, and systems for companies with 20+ extensions. I’m comfortable recommending this system for a business with up to 100 extensions, more than that and you might want to look at having dual load balanced servers.

For this setup I’m going to describe below, we’ve got a business with around 30 employees, 20 of which have their own extensions on the phone system. There is a sales group, support group, and various administrators, as well as production staff.

Any $400 to $600 PC will work for our base system. 2.0ghz+ Intel or AMD processor, at least 1gb of ram (I put in 2gb since its so cheap). Looking for hardware with a good warranty? Check out my company SabreTech Consulting LLC for some great PC’s. We ship anywhere in the US (and actually, a lot of our PC’s are overseas as well, thru an associate of ours).

Let me back up for a second and explain the two ways we can get “dial tone” to our phone system (i.e. be able to make calls to the outside world).

Way #1, use land lines thru your local telco, for example ATT or Verizon. Way #2, use voip trunks thru any of hundreds of carriers, this method requires a NICE SOLID internet connection.

Depending on your area and telco providers, it may or may not be more cost effective to use land lines thru the telco. These days I’ve found that its usually cost effective to have enough land lines, with “unlimited” long distance/local packages on them, for your average use (sum of the number of lines you use every minute of the day, divided by the number of minutes they are in use), and then voip trunks for “peak” times when you need Just A Little More, and for international calls.

So, we’ve figured out that our average use is 4 to 6 lines in use at any given minute (this is just calls to the outside world, does not include internal calls, i.e. extension to extension). So we want to get 6 lines with unlimited local and long distance packages, which ends up costing about $456 a month. So how do we get these phone lines into our phone system?

Ok, time to step back again and explain the two ways the phone company can get us a line, digital or analog.

Analog lines are the ones we had when we were growing up, you know, the phone on your wall in the kitchen 😃 These analog lines are also called pots lines. Digital lines, a.k.a. PRI’s, usually come in bundles of 23. In some areas you can get “partial” PRI’s, and if you can in your area, and the price is right, DO IT… Digital lines will be better quality and give fewer headaches than analog lines. The nice thing about digital lines is they either WORK or they DON’T WORK, there’s not much in-between. Analog lines on the other hand, can have a myriad of problems, including dropped calls, static, etc. Analog lines can work, even if the connection is crappy, and therefore its harder to convince the telco that there might be a problem with the line.

So, I want some lines from my telco, but I need to get them INTO the phone system! My absolute favorite company for doing this is Rhino Equipment. They make a series of analog and digital interface cards. These cards ARE NOT CHEAP, BUT they are worth every penny and more. In fact, I would pay twice the price they charge for them, and here is why: they have the best tech support I have ever used in my life. Let me repeat that. THEY HAVE THE BEST TECH SUPPORT ON THE PLANET. These guys have helped me time and time again, always courteous and patient. On one job they worked with me for 3 days trying to troubleshoot dropped calls, and said on day 2 that it wasn’t their equipment, but instead the phone company, but they stuck in there RIGHT TO THE END. They kept helping me, even after they knew it was the phone company and not their equipment causing problems, and if it weren’t for them, I never could have convinced the phone company to get their act together and fix the lines.

For most small businesses, where I can’t get a PRI, only pots lines, I use the Rhino R8FXX-EC card. It can support up to 4 fxo (or fxs) modules on it. Each fxo module can handle 2 pots lines from the telco. This card has built in echo cancellation, just one more reason its worth every penny. For this example, since we’re going to have 6 lines, I need to get the Rhino card with 3 modules on it.

Ok, we’ve got our PC, we’ve got our interface card to interface with the telco, now we just need to pick a phone model to get everyone. I’m going to have to go with this recommendation, the Aastra 57i. I have yet to get this particular model in to try myself, but I trust Ward Mundy with my life, so what he says, goes 😃

Well, two pages in and I’ve decided to split this into a multi part article. We’ll call this Part I. Please keep checking back for Part II, where I’ll cover installing and configuring the software stack and your Rhino card.

Family Ribs

2009-06-28T00:00:00Z

My cousin and his wife Karen (i.e. Family) are visiting us this weekend. My cuz is an artist, an ice sculptor and he also works with sand! This is the second year he has visited us while doing work up in Niles MI, but the first time Karen has come to visit us. In fact, it’s the first time Karen and my wife have met 😃

Anyways, one of the means I used to entice Karen to visit us was my incessant twittering about food, mwahahaha…

Tomorrow Natalie is working, and Stephan is exhausted, so we’ll miss church this week while I get things ready for a big lunch.

I’ll probably be getting up at around 7am to start the smoker(s) (I’ve converted my grill to a smoker too), and be occupied with that until close to 2pm when Nat gets home from work, and hopefully the food is ready. I’m making ribs! St Louis cut spare ribs and baby back ribs!

Karen was gracious enough to help me with the rib prep today. Cutting the spare ribs down to St Louis style ribs and making the rub and then getting all the racks and extra bits seasoned and in the fridge. We (well me at least) had a great time hanging out, talking about everything from their “MONUMENTAL WEDDING!” to when Natalie and I were thinking about starting a family.

Since moving to Indiana Natalie and I have become very very close, but we haven’t made too many friends, so it was really nice to talk to someone else at length, and just hang out all day, being silly, going on a road trip with the dogs (four of them!) to see Stephan, and of course working on the ribs together.

Well, I’ll make sure and post tons of pics tomorrow! I’m really looking forward to this!

Rapid Onsite Software Development

2009-06-24T00:00:00Z

My uncle has been bugging me to help him with writing some software for awhile now, and this last weekend he sent me another email with a new idea, to help him in his business. I had some time available this week, so I decided to drive down to his shop and try something. My goal was to take his simple idea, boil it down to its essence, and write the whole application in a day using Rails.

To prepare myself I started working on TDD again, using shoulda and factory_girl. I also built my own version of bort from the ground up, called pudding (it has a couple flavors, including vanilla and tapioca). I tried to find the right mix of features to give myself a running start when I arrived onsite.

I arrived at 8:30am this morning and started programming at 9am. At first things were going fairly well, building my models out using TDD went fast, and I was rolling along nicely on writing my controllers using TDD when I hit a wall, aka, lack of knowledge on my part. After hitting this wall for 45 minutes I finally gave up on TDD and just went back to my old way of doing things, i.e. no testing.

I was back on a roll again, using my osx theme for the admin interface, and blueprint for the css reset, typography, and layout on the technician facing part of the application (the part that will be used the most).

Things were going along nicely until I ran into issues with the way I was doing ajax modals, via thickbox. I’d already implemented quite a bit using thickbox, when I decided I needed to start over on my modals using a different library. So far I think I’m gonna use jqModal.

So, at 4:30pm I called it quits for the day, realizing my “app in a day” dream was not gonna happen, although I believe I’m about a 1/3rd of the way there, which isn’t too bad.

Lessons learned?

I need to work quite a bit more on testing, I need to know it like the back of my hand
I need to have a sample controller built out in my pudding apps, so I can do a bit of copy/paste when building my controllers
It would also be nice to include my osx theme, and blueprint theme in my pudding apps
I need to get better at jQuery, and find the best plugins for my different needs

Preparing Dinner for Natalie and lil'sis TweetWhiskey Glazed Pork ChopsCountry Style Tomatoes

2009-06-17T00:00:00Z

Whiskey Glazed Pork Chops

1/2 cup Jack Daniel’s Tennessee whiskey
1/2 apple cider
2 tablespoons of light brown sugar
1 tablespoon dijon mustard
1/8 teaspoon of cayenne pepper
1/2 teaspoon vanilla extract
4 teaspoons cider vinegar
4 bone-in, center-cut pork chops, about 1 inch thick
2 teaspoons vegetable oil
salt and pepper
1 tablespoon unsalted butter

Whisk together the whiskey, cider, brown sugar, mustard, cayenne, vanilla, and 2 teaspoons of vinegar. Marinate the chops in a quarter (1/4) of this liquid, set aside the rest.
Remove chops from the bag, pat dry with paper towels, and discard marinade. Heat up oil in a large skillet over medium-high heat until just starting to smoke. Season the chops with salt and pepper, then throw them in the pan and brown both sides, 2-3 minutes per side. Transfer chops to a plate and cover tightly with foil.
Add the rest of the whiskey mix into the skillet and bring to a boil, scraping up any brown bits from the meat. Cook until reduced to a thick glaze, 3 to 5 minutes. Reduce heat to medium-low and drain any juices from the chops plate into the mix. Add 2 teaspoons of cider vinegar, whisk in the butter, and simmer until thick and sticky, 2 to 3 minutes. Remove pan from heat.
Return chops to skillet and let them rest in the pan until sauce clings to them, turning to coat both sides. Leave in there while they finish cooking, about 5 minutes.

Country Style Tomatoes

4 large tomatoes
8oz of cream cheese
1/2 teaspoon dried basil
1 garlic clove, minced
1/4 teaspoon of salt
flour
bread crumbs
1 egg
1 tablespoon of milk
3 tablespoons of butter
3 tablespoons of olive oil

Cut each tomato into four thick slices, and then place on paper towels to drain. In a small bowl beat the cream cheese, basil, garlic and salt until blended. Spread mixture onto half the tomato slices and then top with remaining slices.
Place flour and bread crumbs in separate pie pans, in another pan whisk egg and milk. Coat top and bottom of each tomato stack with flour, then egg mixture, and then bread crumbs.
In a large skillet, heat butter and oil over medium-high heat. Fry tomato sandwiches in batches for 3-4 minutes on each side or until golden brown. Drain on paper towels and serve.

Configuring PBX in a Flash to use Rhino cards

2009-06-02T00:00:00Z

If you are using a Rhino Equipment card as your PSTN or digital interface to the telco, and need help setting it up on your Asterisk-based PBX, look no further!

This google doc has just the instructions you need. (Thanks to James at Rhino for these great instructions!)

Also, as far as telco cards go, I couldn’t recommend anyone better than Rhino. Their cards are great, and their technical support is the best I’ve ever had from any company, EVER. They are, simply put, amazing at what they do.

Oh yeah, when it comes to open source PBX platforms, PBX in a Flash is the best I’ve found. I’ve tried Asterisk@Home, Trixbox, and a couple others. PiaF is easy to set up, clean, and simple.

Evolution of a twitter client

2009-05-22T00:00:00Z

One of my clients wants his employees to be able to use Twitter, but there were some strict requirements involved, and I couldn’t find a Twitter client for Windows that met all of those requirements, so I decided to write my own Twitter client.

I’m modeling it after Tweetie for OSX, of course (in look and function). I know Ruby best, so I decided to use _why’s Shoes and John Nunemaker’s twitter gem.

For those interested in writing a Twitter client and using Shoes, or who like to see the evolution of an app, be sure to check out this article.

This article is going to be updated as I write this app, but I just wanted to start with a slideshow of the evolution of the app so far.

What IT guys do when their bored

2009-05-21T00:00:00Z

What IT guys do when their bored from JonMagic on Vimeo.

First time smoking ribs

2009-05-16T00:00:00Z

Nat and I smoked pork spare ribs over this Memorial weekend, and they were so yummy.

Here is a picture of the rub we made, definitely too intense we found out. We will put together a much simpler one next time. We put the rub on them the night before.

See the recipe here.

We smoked the ribs for about 5 hours at 205 to 225 degrees Fahrenheit in my vertical water smoker.

Here was my smoker setup.

After smoking I wrapped them in foil, then wrapped in a warm wet towel, and threw in a cooler for an hour to rest. Finally we threw them on the grill for 2 to 4 minutes, some with just the dry rub they’d marinated and smoked in, and the rest I threw some store bought bbq sauce on.

Natalie made baked beans and potato salad, so we had quite a feast 😃

NOTE: Things we’ll do differently next time:

simpler rub, and less of it
3-2-1 method of cooking, see here
home made bbq sauce

Integrating with Quickbooks

2009-04-23T00:00:00Z

If you are a software developer working on software for small to medium businesses, then there is a 70% chance (my unscientific calculation) that you’ll run into Quickbooks at some point.

If you want to integrate with Quickbooks, and especially if you are a developer using ruby, then this post will point you in the right direction for getting things done. So please, read on 😃

DISCLAIMER: I am a former associate of Daniel (and BehindLogic) and I got a freebie for writing this post (which is cool cuz I was gonna write it anyway, but don’t tell him)…

I’ve been working on writing software to manage our small IT consultancy, SabreTech Consulting LLC and the time came to be able to integrate with our accounting package, Quickbooks. Awhile back we had tried, unsuccessfully, and so I was not looking forward to it this time around.

But, a friend of mine has been working on writing a Quickbooks gem and recently released it to the wild, so I thought I would take a crack at the problem again.

After getting the gem from him ($199) and the http adapter to sit on our PC that runs quickbooks ($25) I was up and running within minutes. I included the gem in my rails app, fired up my app console, and started creating QB objects and saving them.

In about 5 hours of work last week I was able to build an interface to easily link clients in Suite to clients in Quickbooks AND make it so when you create a new client in Suite it can automatically create the client in Quickbooks, and populate the phone/email/address fields. Having completed this in such a short time I was feeling pretty good! Working with Quickbooks wasn’t a hassle anymore, so I decided that this week I would tackle turning our completed tickets in Suite (work orders) into invoices in Quickbooks.

In just 2 days (really fast for me, I’m a slow slow slow programmer) I had wired up an Invoice model in my rails app, had it creating an invoice in quickbooks and putting in the line items for labor, with quantities and descriptions, setting the thank you message at the bottom of the invoice, and setting the “IsToBePrinted” field so that our manager can just click on File > Print Forms > Invoices in Quickbooks and turn all those invoices into paper 😃

Basically I was able to cut down 3 to 5 minutes of work (for our manager) to a button press and 20 to 60 seconds of server work. That is a time savings (via integration) that most businesses would kill to have.

Now, while I’m super excited about all this, there were some downers (please fix these Dan!):

Documentation is very sparse and sometimes incorrect, I’ve actually offered to help him on it
There are some bugs in the gem. One I found was when creating an invoice and setting the quantity field for a line item, it wouldn’t accept a float, only integers. Daniel replied to my emails within 12 hours, and showed me what to fix in the gem, and said he would fix it soon in the gem and re-release the gem to everyone who had bought it.

All said and done, I highly recommend the Quickbooks gem by Daniel Parker of BehindLogic.

Running Mephisto (and other Rails apps) on Site5

2009-04-20T00:00:00Z

There are a few steps in getting the latest Mephisto (0.8.2 at the time of this writing) working on the shared host Site5. As I’m writing this Site5 is upgrading all their servers to Ruby 1.8.7, Rails 2.2.2, RubyGems 1.3.1, and Mysql 5.0. Thanks to everyone at Site5 that helped, Ben, Beau, and the guy I talked to today (forgot his name). Continue reading for the steps I/we had to take to get things running properly.

UPDATE: Please make sure to update your .htaccess, Site5 now supports mod_rails on most, if not all of their servers.

Get your own gems repository working

ssh to your account and in ~/ create a gems dir.
```
mkdir gems
```
create a .gemrc file in ~/
```
nano ~/.gemrc
```

paste the following in (changing username to be your user)

gemhome: /home/username/gems
gempath:
  - /home/username/gems
  - /usr/lib/ruby/gems/1.8

edit (or create) .bash_profile in ~/
```
nano ~/.bash_profile
```

paste the following (changing username to be your user)

export GEM_PATH=/home/username/gems:/usr/lib/ruby/gems/1.8
export GEM_HOME=/home/username/gems

Now you should be able to run gem environment and see the correct values.

Downloading Mephisto and getting it setup.

I downloaded the latest release of Mephisto from http://mephistoblog.com/download, version 0.8.2 Drax Fixes. Once I had it on my dev machine I scp’d it up to Site5. There I created an apps dir in ~/ on my Site5 account, and untarred mephisto there. I renamed the dir to mephisto_0.8.2 and got to work on configuring stuff. First I copied config/database.example.yml to config/database.yml, went in and deleted all the extra lines, and just configured what I needed. I like to configure my development database, and then for the production one just have it point at the same settings like so:

development:
  adapter: mysql
  database: username_database
  username: username_dbuser
  password: password
  host: localhost
  encoding: utf8

test:
  adapter: mysql
  database: username_testdatabase
  username: username_dbtestuser
  password: password
  host: localhost
  encoding: utf8

production:
  development

I’ve been getting into testing stuff more lately, so I went ahead and configured a test database as well. Remember back at the beginning how we had to setup our own spot for gems? Well now we need to tell this application where to look for those gems, and put our app into production mode. nano config/environment.rb and set the top five lines to look like this (leave everything else alone in this file, oh, and make sure to replace username with your user):

# Be sure to restart your web server when you modify this file.
ENV['GEM_PATH'] = '/home/username/gems:/usr/lib/ruby/gems/1.8'
# Uncomment below to force Rails into production mode when
# you don't control web/app server and can't set it the proper way
ENV['RAILS_ENV'] ||= 'production'

Preparing dependencies and tell Apache what to do with requests!

At this point you’ll have to run the following commands inside your mephisto dir to get our dependencies ready.

rake config/initializers/session_store.rb
rake gems:install
rake db:bootstrap

THE FOLLOWING .htaccess STUFF IS OBSOLETE, PLEASE JUMP AHEAD

Once you’ve got that done we’re almost there! The next to last thing is add an .htaccess file to our public folder so that Apache knows to execute dispatch.fcgi when a request comes in. So nano public/.htaccess and paste the following:

Options +FollowSymLinks +ExecCGI
RewriteEngine On
RewriteRule ^$ index.html [QSA]
RewriteRule ^([^.]+)$ $1.html [QSA]
RewriteCond %{REQUEST_FILENAME} !-f
RewriteRule ^(.*)$ dispatch.fcgi [QSA,L]
RewriteCond %{HTTP_ACCEPT} application/xrdsxml
RewriteCond %{HTTP_ACCEPT} !application/xrdsxml\s*;\s*q\s*=\s*0(\.0{1,3})?\s*(,|$)
ErrorDocument 500 "Application error
Rails application failed to start properly"

OK, NOW THAT Site5 SUPPORTS mod_rails MAKE YOUR .htaccess LOOK LIKE THIS

PassengerEnabled on

Last but not least we need to go to ~/ and rename public_html to public_html_old and then create a symlink like so:

ln -s ~/apps/mephisto_0.8.2/public public_html

That’s it! Open your browser and try to access your site. Things should be working at this point.

If it returns "Rails application failed to start properly” start looking to make sure you have all the gems you need. One thing I like to do is from my mephisto dir, run ./script/console and do a few db lookups, then if that works I run ./script/server -e production and then in a second ssh session to my Site5 account I’ll do a curl http://localhost:3000/ to see what it returns. Often you can see the exact error doing it this way, and fix the problem!

OTHER NOTES:

Do not install image_science gem even though mephisto works with it now. Site5 does not install freeimage on their servers, only imagemagick, and the Rmagick gem, so just go with those.
You could automate a lot of this with Capistrano, but if you are only doing it once, why bother? I use Capistrano in a lot in other instances, but was just lazy here 😃
Make sure your permissions on your public folder and dispatch.fcgi are set to 755

A little story called fun

2009-03-30T00:00:00Z

This last weekend I took my wife to Chicago for her birthday, and her best friend flew in from Boston to join us. We had a wonderful weekend, they got to go shopping, we all got to eat amazing food, and I managed to talk them into going to blues and piano joints rather than dance clubs (except for one place that had Jazz upstairs and dancing downstairs).

Sunday before taking Michelle to the airport we all went to Ikea so Natalie could do SOME MORE shopping 😃 Michelle and I were kinda tired, and bored, so while sitting on a very nice leather couch I suggested we play a game. We would co-write a book, taking turns, using our phones and facebook status. The rules were: no more than 255 characters per post (I think Michelle’s was limited to 140), and no colluding. So basically we didn’t set up the story in any way, it just worked itself out as we went along.

The game ended up being tremendously fun, and got us through the better part of the day, including an hour or two of the time Michelle had to spend in the airport, because her flight was delayed. Because we were doing this on facebook, and it would only make sense if you were friends with BOTH of us and saw the updates coming in sync, a lot of people thought we were absolutely off our rockers. In fact, this comment to Michelle from her friend pretty much sums up what it must have looked like:

DeAnna: sometimes i read your status updates and think you are on crack. i think a crackberry is bad for someone already addicted to crack….

p.s. i would have called you this weekend, but clearly you are having fun with your bffs. and taking lots of crack. so later this week?

If you were one of those people only getting half the story, I’ve included the whole thing if you click thru to read the rest of this post 😃 Enjoy

The Beginning

2:20pm Jonathan woke to the phone ringing. Ok ok he thought, and slid his finger across the face of the iphone to answer it

2:22pm Michelle was on the other end of the line, “That’s it Jonny-Boy, we’re done for”

2:25pm Jonathan jerked the rest of the way to consciousness. “what!” he screamed! “You didn’t stop the package in time?”

2:28pm Michelle , stunned by Jon’s reaction lost composure " ME?? ME not stop the package in time!!! since when was that my responsibility you…hold on, another call"

2:49pm Jonathan started racking his brain, when had he ever taken responsibility… Didn’t matter, the cat was almost out of the bag, and there was nothing he could do about it, short of storming the courier service and going Jack Bauer on em

2:52pm Michelle clicked back onto the line “sorry about that it was Z and he is NOT happy we’ve gotta get down there like now” she finished as she climbed out of bed

3:01pm Jonathan said “meet you in 15, corner of le salle and ohio” and he hung up. Throwing some clothes on he grabbed the already packed bag and bolted for the door. He never looked back, but couldn’t help but think as he raced down the steps that that was the last time he would see his apartment on the north side

3:05pm Michelle jumped into her Mini that the driver had brought around “thank you marcus” she umbled as she climbed in and slammed on the gas.

3:12pm Jonathan neared the corner, and saw her mini zipping east on Ohio towards him. To his left he heard an suv accelorate, and instantly knew things were about to go very wrong

3:17pm Michelle saw Jon walking down the street and thought “damn hippies” and threw the wheel to the right and slammed on the breaks inches in front of him,he looked worried.

3:41pm Michelle looked at the silent Jon “hello! what’s wrong with you? you’re not talking now? get in we need to hurry”

3:39pm Jonathan jumped in and grumbled something about company coming “in like 2 seconds” and that they probably weren’t here to play nice

3:48pm Michelle looked to the left and saw the SUV reeling around to backtrack at them “ugh. again?” she said throwing the mini into first and peeling out “any idea who?”

4:02pm Jonathan said "well I’m guessing it’s not one of my ex girlfriends"he twisted his head around and saw three heads through the windshield of the approaching suburban and they definately looked Spanish

4:04pm Michelle looked at him. “spanish? you think that you can tell someoines exact NATIONALITY from a hundred yards away in a soeeding car? gimmee a break!”

4:05pm Michelle kept her eyes on the road, “look let’s just get to Z without incident and figure out who the hell they are then. got your passport?”

4:08pm Jonathan said “which one?any idea where we might be going? I just hope Z gets us outta here sooner rather than later. And I don’t care if I ever see Chicago again”

4:32pm Michelle glanced in the mirror and saw they had lost the SUV, “good question. call Z let’s find out what the hells going on” she said as they pulled up to the terminal

4:43pm Jonathan picked up his phone and dialed.“z, where we goin’?we gotta get out of here fast!” “Sophia? Ok, whatever.”

4:50pm Michelle looked at Jon blankly "sophia? really this day keeps getting stranger and stranger. guess we’re the… Walshes then. Lee and Lea brother and sister again. C’mon

4:57pm Jonathan grabbed the bags and plastered a smile on his face. “you know, the more I think about it, those thugs may have had something to do with an ex, I think her family was connected in certain parts of Europe where the Spanish might have power.”

5:01pm Michelle laughed and slipped on her glasses “right your long line of European exes… Spanish exes” shaking her head they walked inside ignoring the cries of the bellman

5:07pm Jonathan stayed cheery as they grabbed their tickets at the lufthansa counter. “Our connections in Frankfurt, maybe we can grab a pint while we’re there.”

5:17pm Michelle nodded in egar agreement, they quickly passed through security and took two seats in the lounge. just as she was about to nodd off she heard a familar voice

5:23pm Jonathan didn’t even turn around as Z began to berate them them from where he was seated. “you guys are getting sloppy, someone want to explain why that recording is on it’s way to the PM right now?”

5:27pm Michelle whipped around “damn it Z! you know if you’d quit hiring rookie couriers we wouldn’t be in this mess! I told you we couldn’t trust that kid”

5:37pm Jonathan interjected, “I don’t see how this is helping, the damage has been done. All we can hope is that Obama’s staff find the traitors in time and bring the operation down.” “in the meantime I suggest you tell us what our next assignment is.”

5:42pm Michelle glared at jon for a brief second then decided he was right and looked to Z for the answers "look I dont know anymore than that you both need to be on that plane

5:47pm Jonathan wondered if this had anything to do with Petrov, it had been 5 years since they last worked together, and hadn’t he gone civ and back to his home country? No matter, the announcement came over the speaker that it was time to board

5:51pm Michelle gathered her bag and headed to the plane. this wa s always her favorite part- the calm before the storm, the plan before the chase. she couldn wait to land

5:56pm Jonathan fell asleep before the wheels left the ground, waking only when “sis” shook him because she was bored. “wudda you want?” he grunted at her

5:59pm Michelle looked down at him. " do you think…no. sorry" he glared at her"what?" he asked annoyed “do you think that Petrov might be involved? I know its crazy but”

6:03pm Jonathan perked up a bit, “yeah that’s the first thing that came to my mind! But why would he need us? We’re mostly just the Company’s grifters.”

6:06pm Michelle nodded in excitement, “maybe our time has finally come! I mean we’ve been schleping with intelligence for 6 years, maybe they’re moving us up!”. she babbled

6:14pm Jonathan snickered, “oh does lanky lea wanna be a double 0?” “that’s so cute”…

6:21pm Michelle punched Jon in the arm and rolled over to go back asleep secretly hoping that she would be

6:30pm Jonathan checked their next boarding passes as they exited the plane, “looks like we’ve got about 8 hours to kill. Wanna go to that one place where we met that one guy that one time, you know, the guy with the dog?”

The End

We have crossed the border.

2009-02-28T00:00:00Z

When I first got started in computers professionally (while still in highschool) I never dreamed I would be a partner in a company that did business internationally. Before I tell that story let me give you some background.

I am a partner in a small IT consultancy based out of southern Michigan. My first partner (Brad) and I bought SabreTech Consulting LLC from an old friend of mine in the summer of 2005. We’ve been selling and servicing computers for businesses and individuals since then, doing our best to make sure the customer comes first. In 2007 Sam joined us (and became a partner in 2008) and we continued to expand into northern Indiana and Ohio. Business has been great, we’ve even purchased a new (and bigger) building in Michigan and moved our retail location.

But this week things really got interesting. One of my clients in Hillsdale asked me if I could help his friend in France. I said sure, so he gave me her email address and I setup a meeting. Tuesday her and I skyped, and then started a remote connection so I could fix her computer. How cool is that! SabreTech Remote Connection from Elkhart Indiana to Versailles France 😃

Later I was bragging about my remote to Sam, and he was kind enough to inform me that one of our clients that buys custom embedded systems from us was sending our equipment all over the world, Canada, Peru, Ireland, and Egypt!

God has blessed me with an amazing wife, family, business partners, and now an international business.

Except for putting my back out, it’s been a great week 😃

Moving to Disqus for comments

2009-02-21T00:00:00Z

I’ve been thinking about using Disqus for awhile now and finally decided to bite the bullet when I realized I just couldn’t get the features I wanted out of Mephisto’s built in comment system.

Setting Disqus up on your blog is easy enough, they’ve got automated stuff for the popular hosted blogging platforms, and easy to insert html/js for those of us running our own custom blogging systems, like Mephisto.

If you are interested in doing this yourself, read on!

I wanted to be able to keep the 90+ comments I had already though, and importing didn’t look like it was going to be easy. But then I found Michael Ivy’s post on importing from Mephisto to Disqus and got excited at how easy it looked to be. At first I tried using his vanilla script, just filling in the blanks, but quickly realized there were some problems:

The script didn’t account for your MySQL db having a password
It gets the article URLs from the article RSS feed, which only returns the last 15 articles by default

I started tackling the first problem by just changing one line in the script to look like this:

db = Sequel.mysql(db, :user => db_user, :password => db_pass, :host => 'localhost')

and then adding db_pass = 'password_here' to the options stuff above. This kind of worked, except that one of the last lines in the script

puts "Success: #{comment.author} on #{comment.title}"

errored out on comment.author, because Sequel isn’t taking into account relationships between models in Mephisto.

At this point I decided to rework it a little and just use ./script/runner to run the export script, so that I could take full advantage of the Rails app relationships. Here is my updated script.

Things still weren’t quite right though, I either had to modify Mephisto to get back all my articles from the RSS feed, or just use ActiveRecord to pull all that stuff. I decided to edit app/controllers/feed_controller.rb and remove the :limit => 15 lines from the three methods at the bottom of that controller. I put them back afterwards 😃

That should be it, worked great for me, putting all my existing comments into Disqus. Then I just had to modify _comments.liquid, _entry.liquid, and layout.liquid using the built in template editor in Mephisto.

…nuf said

A light at the end of the tunnel

2009-02-08T00:00:00Z

I know it’s not really spring yet, but I can’t help but get my hopes up. Today around noon we reached 41 degrees, the sun was out, and it just felt amazing outside.

To celebrate I cleaned out my car 😃

Then at 3pm we took the dogs for a walk—only Bailey’s second walk, and his first to the park. When we got home, Natalie gave Bailey a bath in the sink while I gave Leo a bath in the tub (first time doing each of them alone; quite a trick). Now I’m grilling outside, with sandals on!

I’m sure next week the temperature will be back down in the teens, but I can’t help but get excited.

…nuf said

The car that wasn't broken

2008-12-23T00:00:00Z

Saturday I had barely returned home to Indiana (from MI) when Natalie called me. She was leaving Target and Kohls in Goshen and wanted to know what I was up to. About a minute into the conversation she said “crap, gotta go, the car just died…” A few minutes later she called back, the car was dead, in the

Feeling the love

2008-12-18T00:00:00Z

Wow, I must have more friends this year than ever! Several friends called to wish me a happy birthday, I got 10 happy bday text messages, and about 20 emails!

So anyways, thank you everyone, it was a great birthday. I actually took the day off, the first time since before college I remember not working or taking exams on my bday (except for that one time our prof brought us into class for the exam, and then told us all we got an A and to have a nice day).

This morning I went Christmas shopping for my wife and my sister. Then this afternoon/evening I smoked a chicken out in the garage. Tina (my lil’sis) showed up a bit after four and she chilled in the garage with me for a couple hours. At 7pm Nat got home from work and we skyped with mom and dad and had a mini-birthday/Christmas party. Since this was our only chance for all of us to get together (virtually) we opened gifts and just had a wonderful time. After that we had an amazing dinner together and watched a movie. To top it off we had Tiramisu that Natalie made… mmm, good.

In the past I haven’t always looked forward to my birthday. From now on, I think I will.

…nuf said

Globe Gravity Feed Slicer

2008-11-22T00:00:00Z

This is a post from my old blog that I’ve put up for solidarity. To this day I still get emails from people inquiring about this model slicer 😃

About a year before my parents headed to South America they started getting rid of most of the stuff they’d accumulated over the years. One of the last things they gifted to Natalie and I was a meat slicer that looked pretty beat up and rusty, but had promise for anyone willing to take the time to take it apart and restore it.

It’s been sitting in my garage for several months now, collecting dust and more rust. But last weekend, as part of my meat smoking tradition (started about 6 weeks ago, see older posts for fun smoking adventures), I decided I wanted to thinly slice the meat I smoked, and I’m not very good at thinly slicing meat with a knife, so I needed something more.

I dug the meat slicer out of the corner of the garage, carried it inside (without putting out my back!) and got to work.

I started by taking it apart, a bit of a challenge the first time, but I’m sure it will be easier in the future now that I know what I’m doing.

Here are all the individual parts laid out on my counter ready to go into the dishwasher. Oh yeah, I also used a toothbrush and baking soda to scrub the rusty spots and remove about 90% of the rust.

While the parts were in the dishwasher I started researching this slicer. A Globe Gravity Feed Slicer, Model #150, Serial #223739.

Couldn’t find much on the internet, other than Globe’s Website, and that they are located in Dayton Ohio. They did have contact info on their website though, so I shot them an email asking if they could tell me more about my slicer, and if they had any manuals or accessories for this thing lying around in a warehouse.

When the parts were done in the dishwasher I put it back together and my did it look good!

I used it to slice my smoked beef shoulder roast that night (that’s a whole other story, 14 hours on the smoker + 2 hours in the oven crazy) and also sliced some cheese, onion, and bread. It works beautifully, really quite cool. The only problem now is figuring out where to put it 😃

One last thing: Globe did email me the following Monday, and explained that the current owners bought Globe in 1993, and did not have anything from this old model slicer around. They did tell me though that it was manufactured in 1949.

…nuf said

jquery.quickselect.js

2008-11-12T00:00:00Z

Thanks to Daniel for creating a nifty new jquery plugin for me! Quickselect takes select/option tags in HTML and turns them into an input box with live search, and can even use the quicksilver.js for more interesting search results.

I needed this for Suite, the software I’m writing to manage my company SabreTech, and I could not for the life of me find a jQuery plugin that did something nifty like this. I had found this autocomplete plugin, and this live search plugin (which was actually a rewrite of another plugin by a friend of mine, John Nunemaker)…

So I asked Dan to write this up for us yesterday, and this afternoon he found some time and put it together, and guess what, it works PERFECTLY!

Well, I hope others find this useful…

Temperature Time

2008-11-01T00:00:00Z

Ok, so last weekend I totally botched the brisket. It was slightly edible, more like a steak than anything I guess, but a really, really tough steak. So, rather than give up I’m getting right back on that horse till I can ride thru to the end.

But, being like my father, I’m not going to settle for mediocre tools. My smoker only came with a simple thermometer in it that says Warm – Ideal – Hot, with no temperatures in degrees on it. I could have just gone and bought an $8 oven thermometer and attached it, but I thought I’d get something a bit cooler and take my time installing it 😃

It’s easiest to tell this story with pictures, so here goes. This first pic is the Brinkman el-cheapo smoker pre-mods.

Next up are the tools and parts I used (minus the bandsaw).

Here is the chunk-o-wood I cut with the bandsaw.

Next I clamped on my chunk of wood and drilled holes for my bolts, then I bolted it on, and finally drilled a couple holes for the thermometer probe.

I inserted the Maverick wireless thermometer probe and put on the grate.

Here is a pic from another angle without the grate on.

And last but not least here it is with everything installed and the transmitter and receiver running.

You can see the entire flickr feed here

Hopefully tomorrow night I’ll be able to blog a good report about my next brisket. This one is 4 pounds and purchased from a local butcher rather than from the grocery store. Here’s to hoping!

the Smoker Trifecta

2008-10-24T00:00:00Z

Two weekends ago Natalie bought us a smoker (for smoking meat you silly). This weekend I will complete the trifecta of smoking. The first weekend we smoked pork using this recipe in order to make pulled pork sandwiches, last weekend we smoked a chicken using this recipe and it was amazing, and this weekend I will complete the trifecta by smoking a beef brisket using this recipe (please see the rub and mop as well) from the smoker king himself.

I know, I know, I haven’t done ribs yet. But I will have done pork, chicken, and beef, so I believe we’ll meet the dictionary description of a trifecta:

“a run of three wins or grand events”

Time to start smoking!

…nuf said

OSX Styled web gui

2008-10-15T00:00:00Z

I’ll probably get in trouble for this, but I decided to release it anyways… I’ve been working on some software for running my company and needed a nice GUI, implemented in HTML/CSS/JS. I decided, since I prefer using OSX over any other interface, I wanted my web app to look like OSX too.

So I started from scratch and made up this GUI using minimal HTML markup, simple CSS (I use the blueprint CSS library as a foundation), the jquery JavaScript library (including jQuery UI elements), and the famfamfam silk icon set.

This is not TOTALLY OSX themed, as I couldn’t find any tabs anywhere in OSX that worked for web apps (at least not easily implemented ones), so I used the jQuery tabs instead and just made them match as close as possible to the rest of the theme.

Caveat

This will not work in IE (I’m pretty sure, but haven’t tested), but it does work in modern versions of WebKit-based browsers (Safari and Chrome) and Firefox.

Here is the link to my GitHub repo

What is my passion?

2008-08-21T00:00:00Z

I’ve had a hard time with this question lately, and it has been coming up time and time again. I’ve been praying about, asking for guidance, trying to figure out what I should be pouring my heart into.

While nothing really jumps out, here are a few things that I enjoy doing and do a lot:

My job, fixing people’s computers, making people happy
My family, doing all the little things that make Natalie happy, even if she doesn’t realize it
Programming, for fun, for work, for side projects

So according to this article, I should blog about something I’m passionate about. I guess I’ll have to redefine that to somethings.

Summer in a nutshell

2008-08-21T00:00:00Z

Last year I got married. Natalie and I had bought a house in Elkhart, Indiana, and we moved there the same week we married and have been making a home here since then. My memory is so bad I can’t remember what we did last fall, winter, or spring, but I do remember most of this summer 😃

Natalie started a new job this summer and is loving it. Late spring I picked up a bad habit, gaming, and it has stuck with me through the summer. More notable is our vacation in June, where my brother-in-law and sister-in-law came up to stay with us, and we rocked Elkhart AND Chicago 😃

But the most important thing that happened this summer in our lives wasn’t even something that happened directly to us. My parents finally got all their support (to become missionaries), spent a couple months getting ready, and flew to Argentina to start new lives as church planters (these events did not necessarily happen in that order). This has affected us though—now neither Natalie nor I have parents close by. The closest immediate relative is my sister, an hour away.

As summer closes up we reflect. It was a good summer, full of life changes, some surprises, many blessings, and a few hard times.

Getting hacked

2008-06-20T00:00:00Z

My worst nightmare happened last night, and I didn’t even know it until late this morning. I was hacked…

Sequence of events:

June 19th

10pm EST – hacker figured out my email password, logged in, and sent out a mass email to the top 20 people on my contact list (most contacted people), thankfully gmail calculates this list only when you use the web interface in gmail, which I haven’t used in quite some time since I switched to using Apple Mail.app. Most everyone on the top 20 were family or friends. Mysteriously the hacker does not send the mass mail to Sam or Xian, who were both on my top 20 list. The two people who would have known to call me (rather than email me) and tell me to take immediate action.
10:16pm EST – Hacker? tries logging into my blog admin section from this ip 90.194.192.57 unsuccessfully
10:20pm EST – Hacker? successfully logs into my blog admin section from this ip 88.191.47.11
10:23pm EST – Magically whoever logged in at 10:20 is now logged in under a different ip 128.197.11.30 and figuring out my blogging system
10:29pm EST – Hacker figures out my layout management system and starts adding javascript to my template files, first my tag.liquid file
10:31pm EST – Hacker finds my layout.liquid file, the master layout, and adds several javascript lines in there. They cause anyone who visits my site to get forwarded to a nasty porn storm site, and installed some sort of tracking js linked to cetrk.com and crazyegg? Keeps updating the

i'm stoked by the waybackmachine

2008-05-29T00:00:00Z

Man, I was just thinking the other day about all the content I’ve lost over the years switching blogging platforms. Then I listened to a podcast (most likely from Leo Laporte’s TWIT network) and found out about the WayBackMachine on archive.org… I know I’ve heard of it before but always thought “what is that good for anyway???”

Well today I checked it out, and all my blog posts from 2004 and 2005 are on there 😃 There are tons of other sites I’ve lost, most of which I probably won’t ever find not because the way back machine doesn’t have them, but because I can’t remember the URLs…

Anyways, it was just fun reading some of the stuff I wrote a few years ago. I actually sounded smarter back then 😛

Summer Project

2008-04-21T00:00:00Z

I’ve been using laptops for almost 7 years now, which means I haven’t really had the need for a desk in the last 7 years (I travel a lot for my job). I’ve been building my gaming rig over the last 2 months (since I’ve only started gaming again in the last few months) and it’s been living on an old dining room table in one of our bedrooms upstairs. While functional, it’s kinda wobbly and just doesn’t have the look and feel I want.

So today I started building a desk from scratch (well, from wood actually). It’s gonna be a nice corner desk with one side dedicated to my gaming rig and the other side for my laptop and work related stuff (i.e. printer etc)…

I’ll post photos of my current setup and then my new desk as building progresses. All I’ve started today is the tower cabinet that will hold the gaming rig; basic construction is done and trim has been cut but not attached.

You can see the whole set of pictures on my flickr.

…nuf said

New parts coming

2008-04-19T00:00:00Z

Ok, I broke down and purchased the next couple of upgrades for my gaming PC… The first is actually one I linked to on the last gaming pc rig post, the PNY Geforce 9600 GT with 512mb… The second is this little puppy, so I don’t run out of juice 😃 I’ll post how things work once my parts arrive!

I'm back! into games that is

2008-03-11T00:00:00Z

Ok, so that’s not quite true, I did play some Counter-Strike and stuff last year, but last night and today I really got back into gaming.

What better way to get back into things than play Portal by Valve… Part of the Orange Box this game is a strategy game from a first person perspective, and it was fantastic… I don’t know if I’ve ever enjoyed a game that much. The story was simple but interesting, the narrator/boss was hilarious, and it had the best game ending I’ve ever seen (I kinda knew how good the ending was before I played it though cuz of Jonathan Coultan’s jump into fame).

Anyways, I guess Wednesday Xian is going to get me into Team Fortress 2 which he plays a lot and speaks very highly of…

…nuf said

I'm building a computer

2008-03-07T00:00:00Z

I know, I know, that’s not a big deal considering I’m part owner in a computer store. But it IS a big deal to me, cuz this computer is going to be my tech/gaming machine for my house. Here is the spec list:

Asus P5W DH Deluxe
Intel Core 2 Duo 2.2GHz with 2MB of L2 cache
2GB of DDR2 667MHz memory
80GB 7200rpm HDD
plain old black computer case
Lite-On 16x DVD-burner
MOST IMPORTANT: Nvidia 9600GT video card
"Acer 19[LCD monitor](http://www.newegg.com/Product/Product.aspx?Item=N82E16824009091)
best keyboard I can find lying around
Logitech MX-518 gaming mouse

I’ll also either be setting up some nice speakers, or get a nice little USB headset for talking in my games 😃 Fun fun…

Did I mention I’m stoked?

Macbook Air smells like

2008-01-16T00:00:00Z

Nah, I know, it’s pretty. But has anyone else noticed that they are switching back to IDE? I thought that everything was going to SATA. I guess after reading up that it doesn’t make much difference, but, whatever.

Ok, so I’m upset because I wanted a new laptop, and they didn’t come out with one I want. Guess I’ll have to wait for the MacBook Pro updates.

…nuf said

Capistrano recipe and howto for Rails, Mongrel, and Nginx

2008-01-10T00:00:00Z

UPDATE: This is outdated due to the release of Capistrano 2… I will work on a new tutorial as soon as I have a project I need to deploy… 1-10-08

All righty then. Recently my firm (SabreTech) got a contract to write and deploy a fairly complicated web app for a local business. Immediately I asked my friend Xian to give me some deployment ideas, and he suggested I use nginx as my web server instead of Apache as well as Slicehost as my vps host provider…

So I set up my Slicehost account and started hacking. About a week later (five hours of work snuck in here and there), I’ve got my vps up and running smoothly. I’ve been using Capistrano for deployment for awhile, but I also wanted to use it to set up my server, and that is when I ran across deprec. Deprec is a nice little gem with a ton of capistrano recipes for setting up and deploying a server. It had some great recipes for deploying to Ubuntu, so I chose Ubuntu as my OS for my new slice (vps).

Now I just had to write some of my own recipes for setting up and deploying with Nginx instead of Apache. That is where most of my time was spent. Below you’ll find my instructions and recipes:

Prerequisites

Install the capistrano and deprec gems on your development machine
Cap your app; in the root of your app dir, run: cap -A
Set up deprec: from the root of your app, run deprec_dotfiles which just creates a file in your user dir called .caprc, which contains the following line: require 'deprec/recipes'
Your server must be running ubuntu (it should work on any debian based OS though)
Your svn repository must be accessible by the same user listed in your deploy.rb
nginx.conf, database.yml.production, and deploy.rb must exist and be configured in app/config (and checked into your repository)
You need to take this file and append the contents to the bottom of your config/deploy.rb (these are the recipes I wrote)
Make sure and configure the mongrel settings in your deploy.rb

Instructions

Log into your server as root and add a new user (the user you specify in your deploy.rb), set the password, and finally add to sudoers file
1. useradd -m bobby
2. passwd bobby
3. visudo
From the root of your app run: cap install_rails_stack_with_nginx
The last one takes a while, but when it is done run: cap svn_cache_credentials
Finally run: cap deploy_first_time
1. (When it asks for mysql user password just press enter, unless you changed the mysql root password)

Files

Gravy of life

2007-11-28T00:00:00Z

A must read on my mom’s blog. Who knew she could take 15min of thanksgiving table fun and turn it into something worth reading 😃

SabreTech Employee blogs

2007-11-16T00:00:00Z

My team at SabreTech has been busy building their own personal blogs!

Sam Sallows has his new blog up at www.samtheslacker.com

and Dan Parker has had his up for awhile at blog.behindlogic.com

Sam already has an excellent bit on what we can do for clients that need to run older Windows apps that will only run on an old OS like Windows 2000 or Windows 98…

Ultimate media/backup server

2007-10-22T00:00:00Z

I’ve been using a winxp box in my living room for some time now, and while it works really well, I do find it lacking. Currently it has a 200gb hdd and a 80gb hdd, runs xp pro, has a video card with composite out so I can go straight to the tv, has Azureus and ted to get tv shows, k-lite codec pack with Media Player Classic, and vnc so I can remote control it… Its pretty slick over all, but I’m running out of storage and I want something with more features.

So here are my new requirements:

Easily expandable storage, without reinstalling my OS or adding RAID cards etc…
Smaller form factor, my current machine is a full desktop tower
IR remote control and VNC
auto download shows
act as a backup resource for all my computers in the house, which means it has to have redundant storage
looks pretty, both hardware and software

Well, the only way I know how to meet those requirements is with a Mac Mini and a Drobo storage device.

How I’ll pimp the Mac Mini

I’ll need at least a gig of RAM in the mini, doesn’t matter how big its HDD is though since the Drobo will be plugged into it. I’ll run Leopard with Azureus and ted to get my TV content. I’ll set up AFP and SMB file sharing on it so I can access this baby over the network. I’m not sure yet how I’ll remote control, might use VNC, might not???

What I’ll do with the Drobo

The drobo will be attached to the mini via USB 2.0. I’ll probably start with a few 250gb or 500gb drives, doesn’t matter cuz of the drobo’s magic!!! With the advent of Leopard and Time Machine I’ll be able to set this as a backup drive over the network for all my Macs, never having to worry about data loss again! I’m so excited about this part of it.

Anyways, there are more details to figure out, and of course I need to find funding 😉 But one can always wish can’t they…

Setting up a Mac

2007-08-15T00:00:00Z

Ok, I’ve setup quite a few Macs for friends and clients, tweaking things (even starting with a fresh install and only installing the necessary components, without any extra bloat), installing useful utilities, and arranging things to maximize workflow. I unfortunately have not recorded this process to date and a good friend of mine needs to reinstall his OS and set everything up due to a hard drive crash, so I guess now is finally the time to write down all the steps…

Step 1: When installing OS X make sure to click on any buttons that say “options” or “customize.” The first install screen that gives you one of these will ask if you want to install over top, or wipe and reinstall. I usually use the wipe option. The second screen that gives you one of these two buttons, if you click it, will let you remove all the extra programs you don’t need. I start by unchecking the box on printer drivers, unchecking fonts, unchecking languages, and then I pick through the extras, usually removing stuff like GarageBand, etc. Once you’ve got things tweaked, start the install (you can also skip the media check that it runs)…

Step 2: Some techies say you should create an admin account and then a locked down user account to run in on a daily basis. I find this a nuisance, so I just create my one user on the initial install, make sure I assign a password, and that’s that. If you have security concerns, go to your System Preferences, then to Accounts, click on Login Options, and tell it not to auto login that user.

Step 3: Run all your system updates: click on the Apple in the upper left, then click Software Update.

Step 4: Create a Downloads folder in your home directory or on your desktop, then open Safari and go to the Safari Preferences and set the default download location to that folder. Otherwise downloads go to your desktop and clutter things up real quick. This is a personal preference of course, so do what you will. Also, remove unnecessary icons on your dock and drag a shortcut to your home folder onto the dock (next to your garbage can NOT ON IT!) and also drag your Applications folder onto your dock, next to the home folder shortcut you just put there 😃 On Macs shortcuts are technically called Aliases, but whateva…

Step 5: Tweak Safari a little more by going to Safari Preferences and unchecking the “Open Safe Files after downloading.” Also, I think in older versions of Safari you had to enable Tabbed browsing.

Step 6: Disable Spotlight hot keys by clicking the Apple in the upper left, then click on System Preferences, then go to Spotlight, and on the first tab uncheck both the boxes at the bottom. You will need to do this so you can map CMD-Space as Quicksilver’s hot key later.

Step 7: Download your useful utilities and programs… Fire up Safari and start with these great programs:

Quicksilver is an amazing file launcher/object manipulation tool. Super duper easy.
Firefox is an alternate web browser that many people like.
Camino is my preferred web browser for business type stuff.
OnyX is a great program for tweaking stuff in OS X, including dock position, etc.
Adium is an excellent multi-protocol chat program; it really covers all the bases.
Skype is great for voice and video chat; I use this with my fam and friends.
Joost is still invite-only, but you can sign up to get on the beta list. Joost is an online television set type thingy.
NetNewsWire Lite is an excellent news reader application! Make sure and subscribe to my feed once you install it 😃

I was thinking I used a lot more programs, but with web-based applications really starting to be just as functional as desktop apps, I don’t use nearly as many desktop apps as I used to. Here are some web apps I use all the time:

Gmail is a free email solution, by far the best in my opinion.
Google Docs and Spreadsheets has completely replaced Microsoft Office for my needs.
Google Calendar is a flexible calendar with great sharing capabilities. I also use Gcal as a standalone desktop interface to Gcal.
Del.icio.us handles all my bookmarks. I make sure and go to their help section and drag both the “post to del.icio.us” and “my del.icio.us” bookmarklets onto my bookmarks bar in all my browsers. In Safari, if you make them the first two bookmarks on your bookmarks bar, you can access them with CMD-1 and CMD-2.
Flickr is where I store all my digital photos online. I guess I mostly just use iPhoto on my laptop though, and then upload to Flickr for backup.
I have reluctantly started using Facebook to keep in contact with people, and their Pictures section is also really handy for getting photos to friends and family.

Step 8: Go to the folder you downloaded all these great programs to and start double clicking those installer icons 😃 Some you will expand to a new folder, and then you can drag the app over to your Applications folder on your dock (if you followed step 4). Other installers will actually run a full fledged install app that will copy things to the appropriate places automatically.

Step 9: Go to your Applications folder and look for Quicksilver, which you copied there in the previous step… Double click it and follow the setup instructions. I always re-assign my hotkey to CMD-Space for ease of use. Once Quicksilver is loaded, press CMD-Space to open it, then press CMD-, to open Quicksilver Preferences. I set mine to start at login and sometimes tweak some other settings.

Step 10: I like to open up OnyX and set my dock to the right-hand side and so that it aligns to the bottom; that’s just me though.

This is a good start. I’ll add to it as I think of more things 😃

It's about time

2007-08-02T00:00:00Z

I’m married!!!

Had a beautiful wedding on the beach, check out how gorgeous Natalie was in her dress…

It was a wonderful wedding, about 20 of us on the beach…

More pictures to follow 😃

sabretechllc.com redesigned!

2007-07-13T00:00:00Z

Wow, in preparation for our open house this weekend we have been on a mad spree: remodeling the office, making line cards, new business cards, gift certificates, new tables and chairs, AND a NEW WEBSiTE!!!

Christian Metts took some ideas I had and a bunch of good ideas he had and threw together a layout with images in Photoshop in just a few hours. He sent me 4 images: a header, navbar background, navbar divider, a couple hex codes, and an image with the overall look and feel he wanted…

I took everything he sent and threw it together into a fairly comparable real page using HTML, CSS, and images, all on top of mephisto. It took me about 4 hours, and then another 30 min of Christian showing me how to tweak stuff, and I have a gorgeous site that works in 6 browsers (that’s how many I’ve tested so far). Check out the before, mockup, and after pictures…

By the grace of God

2007-06-06T00:00:00Z

I’m getting married August 2nd on a beach in Florida…

…nuf said

ATT is not my friend

2007-03-28T00:00:00Z

When we bought SabreTech, Brad and I had our phone service changed and found out a nice little policy of ATT (SBC at the time)… We were paying for a static IP address, which means our internet address won’t change on a day to day, year to year basis… But it turns out, if you make any kind of change to your account, dsl or regular phone stuff, they assign you a new set of IPs… This is a major pain for a company like ours, so we’ve avoided making changes to our account since then.

Until last month that is, when we had to have some of our phone stuff fixed because ATT screwed it up (won’t go into details)… Anyways, when we called to have this stuff fixed, we were assured our IPs wouldn’t change…

Welcome Today, guess what I find when I get into work this morning… Our internet is down, and I have a sneaking suspicion it is because they changed our IPs… I call ATT dsl tech support, and after they tested the line I suggested they check what IP range I was assigned and sure enough, they changed it… I was irate, and for once that produced results (I never know which way to go with these things, play the nice guy, or play the frustrated client)…

Thankfully, unlike last time, they were able to get us back up and running within 30 minutes (I had to stay on hold the entire time). This whole thing just burns me though, I’m tired of working with large corps that can’t tell their head from their tail, and unfortunately there are no other options around here… So I guess you just have to pay the price, and lose several hours of your life a year for stupid stuff like this… So if anyone ever tells you service x only costs y dollars from large corp z, make sure you figure in the time you’ll have dealing with their stupidity…

Wedding postponed

2007-03-22T00:00:00Z

Our wedding has been postponed temporarily, I will let everyone know as soon as we have a new date.

I'm officially Jon Magic

2007-03-09T00:00:00Z

I know I know, I market the heck out of JonMagic, but today it’s official… I got my first credit card in the mail with the name Jon Magic on it 😃

…nuf said

Computers shutting down everywhere

2007-03-08T00:00:00Z

I’ve got 6 computers, in 2 states, across 4 clients, all shutting down or restarting randomly… This started happening about 3 weeks ago. There are no similarities between these machines—some I built, some are from other local computer places. None of them have the same motherboard or processor… The only thing linking them is they are all running Windows XP.

I guess this is a cry for help—anyone experiencing the same thing?

I'm ready to teach... well, almost

2007-01-20T00:00:00Z

Two years ago while on vacation in Florida I had an epiphany, one of those moments where something just comes to you, and it feels so right.

My epiphany was to take my consulting business and turn it into a chain, eventually a nationwide chain. There were several pieces to this dream, the first being starting some sort of school to train techs/tech managers, the second being giving them a financial platform to go out and start their own businesses under a larger nationwide corporate entity.

Thankfully I didn’t jump with this idea. The infamous GeekSquad started taking off about that time and we now see what a failed experiment that has been. But today my brain juices are flowing again and I’m getting that bug to do something bigger, bigger than what I’m doing right now.

Now don’t get me wrong, I have absolutely nothing to complain about with my current situation. In those two years since my epiphany I’ve partnered with Brad Cochran and bought a computer sales/service business (SabreTech), and then taken that business from a large debt to out of debt in 18 months (we were blessed to do it so quickly), and 2007 promises to be an absolutely amazing year.

Ok, so I was talking about them there brain juices. Learning from GeekSquad’s failure, I’m not so interested in doing the nationwide sales/service chain thing, but I am interested in the first part of my original epiphany, the tech/business school idea. I think this is an open wide market right now, and I don’t know of any school that is doing it right. There are the ITT tech schools, the 4 year schools with BS’s in computer science, and of course online tech schools. You can also just skip school and go take classes to get IT certifications, specializing in hardware/software/Microsoft/Linux/Web, just to name a few. But how valuable are these really? The people in the tech industry that I respect, that are really going somewhere, don’t seem to be recommending these sorts of education to anyone. So what does it take to become an IT industry leader, a professional with the skills needed to be a great, not good, but great IT consultant (I’m focusing on consultants because I’ve always had a place in my heart for small to medium businesses that can’t afford a dedicated IT person, so they outsource)…

This list will be updated as I continue this thought, but here is a start:

Willing and eager to learn
Able to be self taught
Daring, but cautious at the same time
Calm, cool, and collected
Efficient
Good with people

Question: Can these qualities be taught?

None of these things are specific to IT, in fact, a good tech doesn’t have to have tons of experience with computers if they have these skills. I’m not pulling these ideas out of the air. To be honest, from my personal experience, when I walk into a client’s business and am presented with the problem, over half the time I haven’t encountered the problem, and therefore do not know the solution.

Buffalo Technology, please redeem yourself

2007-01-19T00:00:00Z

I’ve been eyeing the Buffalo Terastation for awhile now, lots of storage in a nice little package. So when the opportunity to buy one came up, I jumped.

One of my clients needed a file storage / backup solution, and the Terastation seemed to fit the bill. I found it for a great price (1TB for 6 bills), punched in my credit card number, and 4 days later it was in my hands.

I received the unit the middle of December, but we were so busy at SabreTech I scheduled the install for after the first of the year. I did go ahead and set the unit up, configured everything via the web interface, and tested it. I left in on the bench for 24 hours running, and then logged in and shut it down, everything seemed to be perfect.

Fast forward 3 weeks, when I go onsite and begin the setup for the client. After plugging it in it did its Star Trek like flashy light thing, then signaled that drives 2, 3, and 4 were either full or not working. I logged into the web interface, and it said those drives were not attached. So I shut it down and then started it back up; same thing. Rinse and repeat, again, the same result… So I took it back to my office, started it up and called tech support.

Fast forward 30 minutes, on hold, finally I get to talk to tech support. They decide the controller must be the problem, as the likelihood of three drives going bad at the same time was slim to none. So they put me on hold and then forwarded me to the RMA department. The RMA department took my info and said they would email me instructions to do an advanced RMA (they ship me a new unit, I ship the old one back in the same box the new one came in, and they provide the shipping tag).

Two hours later I got the email and forwarded it to Brad. He had problems getting the link to work, so I went ahead visited the link (no problem on my computer), and printed the form we needed to fill out and fax in. Brad filled in the form later that day, and the next day I took it somewhere to fax it (we can’t fax long-distance from our office). I faxed it, the fax machine printed out the receipt when it was done, and I forgot about it… That was on Thursday the 11th of January.

Fast forward to this Monday (the 15th) when Brad asked if I had heard anything from Buffalo on our RMA status. By this time we should have received either an email saying our new unit was on its way, or at least a confirmation that they had received our fax. I had nothing, so I called their tech support number again, waited on hold 45 minutes, finally got the tech, who forwarded to the RMA department, who proceeded to tell me they had not received my fax (great)… So I drove somewhere to use a fax machine, faxed it twice (just to be sure), and then called Buffalo again.

By this time I’m not really happy that I have to wait on hold twice each time I call to talk to someone in the RMA department, so after waiting 30 minutes on hold to get a tech, and then another 15 minutes on hold to get someone in RMA, I’m getting a bit hot under the collar. I asked the RMA person whether they had received my fax, they looked and said no. They asked what fax number I sent it to and then told me that was the fax number for the accounting department. After a little bit they figured out that advance RMA requests go to accounting due to the credit card info that is needed, and then it is forwarded to the RMA department. So they had me fax everything to a different number and confirmed that they received it, said they would fast track it and I should get an email within a day or two.

This morning I asked Brad if he had heard from Buffalo, and no was the answer. So this afternoon I called AGAIN, waited on hold for 30 minutes and finally got a tech, who once AGAIN forwarded me to to the RMA department. The girl was very nice as I explained all that had transpired, and took care to read everything they had on their computers, and basically told me they had no idea why it hadn’t shipped out (they did say something about their inter-departmental computer systems taking 24-48 hours to update, what is that about?). Then they promised someone would call me by the end of the business day to let me know where things were at.

Well, the end of the business day has come and gone, and I will never buy Buffalo again, even if they fix this… I know I titled the article with some sense of hope, but by the time I finished writing this, I realized I just don’t have the time to work with companies like this.

…nuf said

Rounding out the year

2006-11-13T00:00:00Z

What a great year! Here are some of the things I thank God for everyday:

I’m getting married!
Brad Cochran and I bought SabreTech Consulting LLC just over a year and a half ago, and it is just about paid off…
Good health the last 6 months (with the exception of today), I even had my wisdom teeth removed (finally!)
I’ve had the opportunity to travel, a lot
New laptop
New (used) car… 98 Malibu
Healthy family! My sis is back from school now too, and that is always nice…

I had other ones, but just can’t remember them all right now… I’m sick and need to take a nap so I can get better, so I’m going to lie down now…

…nuf said

clearcheckbook.com, a step in the right direction

2006-10-24T00:00:00Z

I started using clearcheckbook.com about a month ago and have found it an excellent way to keep track of my spending and account balances. I’m still working on finding a web-based budgeting app, but in the meantime clearcheckbook.com is serving me quite well. They keep adding excellent features too, most notably (and recently) the ability to access my account via IM, and my new favorite feature, payment reminders (which are highly configurable)…

I’m hoping pearbudget.com gets their act together soon and gives me a nice web20 app to do the budgeting part, but in the meantime I’ll settle with my pencil and paper (sorry, just not a big Excel fan)…

My Rig

2006-10-04T00:00:00Z

Not that anyone cares, but I thought I’d post my current computer setup, hardware and software…

The Hardware

I’m the kinda guy that enjoys the bleeding edge (first Mac was an 867mhz PB), so five days after Apple released the new Macbook I had my company order one for me. I got a stock black Macbook from Apple, and ordered 2GB of RAM and a 120GB SATA laptop drive from a third party retailer (can’t remember who)…

The day after the Macbook arrived my memory and harddrive showed up and I installed them. Needless to say, I will never own a Mac with less than 2GB of RAM after experiencing the difference between 512MB and 2GB.

This computer is fast, really really fast, and the 120GB of harddrive made it more than comfortable for having my entire music/photos/movies collection on my laptop, instead of just my desktop machine at home.

The iSight camera is really nice too, although I haven’t really started using it for video conferencing yet.

I love having the black Macbook, but I don’t have anything against the white ones, they are really slick too. The black one does tend to show any grease transferred from your hands, which could drive someone with OCD nuts.

Software

Well first off, I’m running OS X 10.4.8 now.

In addition I bought Parallels and I’m running Windows XP Pro and Ubuntu. I use VirtueDesktops to keep everything clean and easily switch between my OS’s. It is really a thing of beauty and I love to show it off to my clients and of course other geeks (I had it all setup when I went to RailsConf, so that was fun, being that only a few people out of the 100+ people with Macbooks had the same setup).

I use iTunes, iPhoto, iMovie, and iDVD quite regularly. I gave Apple Mail a spin but ended up back with the Gmail web interface as my preferred mail client.

For coding I use Textmate and IMHO there is nothing better.

In addition to these I use Gcal (a webkit based Google Calendar client), Firefox 1.5.0.7, Safari, Stickies, NetNewsWire Lite, Terminal, and a handful of other apps.

Problems/Issues

I’ll finish this post off by mentioning some of the hardware issues I’ve experienced with my Macbook.

The first was an inconvenient problem with the gloriously large trackpad. Due to its large size, and the poor (I hate to say poor, but how else can I describe it?) trackpad button design, the button would only work if I clicked within an inch of the center. This after two weeks of use. I found a nice little remedy (via Google) using some origami, and it hasn’t been an issue since.

The last and worst issue I can remember is when I got the random macbook shutdown problem. Four weeks after I started using my Macbook it started shutting down whenever it felt like. Fortunately it seemed to do it more at night and not during work hours. But after a few days it was doing it all the time. I called Apple and started going through their annoying diagnostics: installing the factory RAM, installing the factory harddrive, reinstalling the OS, etc etc. Finally I got an RMA and sent it in. BUT, it took 16 days for them to get it back to me, which was extremely annoying, especially after being assured it would be back in 7 days.

web20 and economics?

2006-09-30T00:00:00Z

I’m bored… I’m working pretty hard at Sabretech, trying to bring home the bacon, but it is just not enough…

I’ve been spending every extra free time moment reading up on and studying this web trend called web 2.0… What is it about, you ask? Mr. O’Reilly gets it right, I think…

So, I really want to contribute somehow, but I’m a nobody in the web 2.0 world, and honestly haven’t had many groundbreaking ideas in a long time (if ever)… But I will not be deterred, so I’ve decided to start thinking about web 2.0 from an economic standpoint, since that was my focus in college…

That said, don’t come back here looking for amazing insights or anything. Maybe—just maybe—though, I’ll have an epiphany and “make it” in the web 2.0 movement 😃

The longest weekend of my life

2006-09-30T00:00:00Z

I don’t even know where to begin… Simply put, an onsite I started on Friday morning turned into an all weekend marathon of Windows 2000 Small Business Server hacking, repeated reinstalls, Mountain Dew, energy drinks, 3 hours of sleep here, 2 there, running between 25 workstations configuring them and cleaning them up, and a whole lot more… It is now a little past 7pm on Sunday and I’m just praying that I can go home soon…

Learning Rails

2006-09-30T00:00:00Z

Wow, what a couple of weeks (months) it has been…

My intro to rails began a few months ago when a good friend and webdev guy told me he was using it heavily and suggested I check it out… I have never had any real programming experience and while the rails intro video was cool I just couldn’t really get into it (scared, I think). SO, I stayed away for a little while, then came back and jumped on the bandwagon by adopting Typo, a nice little blogging app with a lot of functionality, all built on rails… this saved me from having to learn how to program for a few more months and started to whet my appetite to learn more.

Then, about 4 weeks ago someone (who shall remain nameless) looked me up and asked me to build a web app… I could have shoved the project off on Joshaven, but he is already crazy busy, so I decided to commit. No more hiding in the shadows, no more chickening out because I don’t know how to program, no more excuses… SO, I warned the client that I had no idea what I was doing and asked if he was still willing to pay me, and he was 😃 so now I’m knee deep in this stuff and it’s only getting deeper…

After throwing together a pretty much non-functional demo, and convincing myself that I could do this, I decided I needed to read a book on programming in Ruby before I could really get comfortable in rails. So I ran on down to why’s poignant guide to ruby and finished it in a weekend. Since then life has been a lot easier, at least as far as programming goes.

So I jumped back into the project, started from scratch, and built a highly functional, even pretty, demo in 20 hours (two days)… The client liked it and my friends and family even checked it out. That was Tuesday of last week.

Today is Sunday, although by the time I post this it will be Monday. I spent 3 days trying to get RMagick installed on my computer, finally succeeding late last night. Since then I’ve revamped version 1 of the webapp to run faster, use better naming schemes, and have cleaner code all around (thanx for the input xian, I took your advice on combining controllers).

And that is my learning rails experience. Five slow months of avoiding the inevitable and then four crazy rubyonrails filled weeks.

It's just the weather, thats all...

2006-09-30T00:00:00Z

Good morning…

Isn’t this great weather we’ve been having! Temps have been in the 50’s and 60’s, thunderstorms have been rolling through… I love a good storm.

So I’m wrapping up a big programming project, just doing the final touches here and there, addressing the customers final concerns, and I’ve already started my next project. Sabretech is in dire need of a trouble ticket system better than the one we’re using… We currently use the ticket system module in egroupware, as well as the egroupware calendar module. I can say we are less than thrilled with our current situation… So I’ve started this new project and called it Optiks, short for Opportunity Tickets. As you can see, the first thing we’re dropping is the Trouble part 😃 Dad suggested this, hehe… I’m designing and building this with 37 Signals methodology in mind… Some people would like it to have everything and the kitchen sink… I’m mostly just interested in it doing a few simple things really well, with a nice API and the ability to expand and change it later on… So that is what I’m doing!

Also, looks like I’ll be jamming with Roll the Dice this coming Friday night… I played in church this morning, and then practiced this afternoon with RtD… We didn’t sound too bad i guess 😃

Good Night…

I'm Engaged!

2006-09-30T00:00:00Z

Wednesday, August 2nd, 2006 I asked Natalie Burke to marry me and she said yes… It was our 4 year anniversary (since we started dating) and I’m sure she’s been waiting awhile for me to ask, but I got her completely by surprise (it was awesome!!!)…

…nuf said

I bought one

2006-09-30T00:00:00Z

Actually, my business bought one for me, but still… What am I talking about?

I bought a Macbook this afternoon!

Ok, so I don’t have it yet (hopefully Monday) but I have been looking at Macbook pictures and have been reading about it as much as possible (including a firsthand report from xian)… So here are some links you can check out if you are interested…

That’s all I’ve got so far, but hopefully tomorrow the reviews will start rolling in…

p.s. I bought the black one

Here is the latest I’ve found 😃

I’ve ordered 2gb of RAM and a 120gb SATA laptop hard drive, so come Monday my lappy will be upgraded and reinstalled and rocking!!!

Hamachi all the way...

2006-09-30T00:00:00Z

Ok, I’ve been following the development of Hamachi, a.k.a. way too darn easy VPN for a couple months now… Well I finally started using it today and I’ve got to say… WOW, that was way too easy…

But that’s the way we like it around here — things so easy that you don’t have to even think about them, they just work…

Wondering what the heck I’m talking about yet? Here’s the deal:

Fact1 – VPN stands for Virtual Private Network.
Fact2 – What VPN really means is, I can connect 2 or more computers together, no matter how far they are apart, and they’ll think that they are sitting right next to each other and talk their little computer language to their hearts’ content.
- For example: I have a computer in Michigan and my friend has a computer in California and we want to share files with each other, share each other’s printer, share music, etc… But how can we do this securely without anyone eavesdropping and stealing our stuff? With a VPN of course…
- Does it make sense yet?
Fact3 – VPN’s have not been the easiest thing to configure for a number of years, and therefore were not used, or were used and cost a lot of money…
Fact4 – Today that has changed…

If you go to Hamachi’s Website you can download Hamachi for Windows or Linux and install it and use it inside of 2 minutes. If you use an Apple Computer running OSX then you’ll want to head over to this forum and check it out, or just continue reading as I’m going to give my own little How-To…

First, go to This Website and download the tuntap that is appropriate for your version of OSX.
Second, once that file is downloaded open a Terminal session and browse to ~/Desktop (or wherever you just downloaded that file to).
Type:
- ```
tar zxvf tuntap*.tar.gz
```
Now go to Finder and double click the “tuntap_installer.pkg” icon and follow the directions.
Go to This Website and download the latest version of Hamachi for OSX.
Open the Terminal again and browse to wherever you downloaded the hamachi file to.
Type:
- ```
tar zxvf hamachi-0.9.9.9-12-osx.tar.gz
```
Now in your terminal type:
- ```
sudo tuncfg
```
In Finder, find the hamachi file you just expanded, look in the new folder that was created.
Open the README and follow the directions from there and you’ll be up and running in no time 😃

Forever Remember Me

2006-09-30T00:00:00Z

So I’ve finished my first big programming project, Forever Remember Me, a website catering to the families and friends of those who have passed away… It is essentially a place for these families to create a memorial, and upload pictures, leave comments, and leave tributes (donations, which can go to a charity)… So, make sure and check it out…

https://web.archive.org/web/2012/http://www.foreverrememberme.com

flock, the good and the bad

2006-09-30T00:00:00Z

Well, I’ve got mixed feelings about flock right now. Despite the negatives I’m about to list, you should definitely try it out if you can…

Positives:

It just seems snappier on my 867mhz PowerBook than Firefox. I wonder if they’ve optimized it at all? Firefox’s speed has been the one thing that kept me from switching all my web browsing from Safari to Firefox, so maybe Flock will do the trick?
It looks cool, clean low profile interface, no big ugly extras.
It has great features: blog posting, del.icio.us favorites, flickr bar, and it is based on Firefox, so who knows what extensions and themes will come out…

Negatives:

Limited blog support, won’t work with my typo blog UPDATE I got it working, just had to click “Cancel” after it fails to auto detect your blog, and then it lets you setup stuff manually… I’m posting this update via Flock.
Creating a new favorite with tags does not tag it in del.icio.us (this has to be a bug that they haven’t fixed yet).
There was way too much hype surrounding Flock. Thankfully I ignored most of it, so I’m not disappointed too much, but it still doesn’t quite live up to what I thought it would be… Thank goodness this is only a dev release I’m using 😃

Conclusion: I think this is going to be a great browser, and there is a pretty good chance I will use it as my primary (hopefully only) web browser once it is a little more mature… actually, I’ll use it as my primary now, at least for a few days, and see if I can find any other nuggets hidden in there… nuf said.

Another Year

2006-09-30T00:00:00Z

My head hurts…

I should be going to sleep right now, but I’m having such a hard time letting go… this has been a crazy week of late nights programming, long days at work, and crappy weather… but it has been a good week. I’ve learned a lot, spiritually and vocationally… I worked 12 hours today and accomplished a lot, even had lunch with a good friend and mentor. My coworker, Josh, and I have been getting along extremely well, which is exciting in and of itself. He had a pretty killer week but stayed on top of things and didn’t lose it (which is good, because I’ve been worrying about him)… So all in all, I’m pretty excited to be going into tomorrow—Friday, the last day of the week. I’ll be out of state from tomorrow morning until Saturday evening (weird, I’ll be 24 then).

Another year gone past, the best year in a lot of years if you think about it… new beginnings, painful endings, learning, appreciating, worshipping, crying, calling, moving, working, wondering, loving, living, dying.

Time for change

2005-09-28T00:00:00Z

I’ve been meaning to redo my site for quite some time now… blosxom was great, but with time come changes. So I’ve switched to using Typo for my blogging engine… It was built using RubyOnRails, a new web development framework that is pretty nifty…

What does this mean for you? Not much really, a new look and feel… My old site is still there with all the old content, just use the links on the right to access it… I considered importing all my old posts to the new system, but decided I don’t have enough time.

What does this mean for me? Again, not much. It’s going to be easier to post now, and I can enhance my site using quite a bit more as I have time… Any new feature I want I can implement, whether someone else has done it or not… Hopefully this will get me excited about blogging again, so you my poor reader(s) do not get bored 😃

Don’t forget to change your newsreaders to point at the new xml feed…

jonmagic.com

The Feedback Loop I Was Missing

# Speaking with the agent

# Audio triggers different brain pathways

# Turning say into Relay

GitHub Copilot Session Search and Resume CLI

# e-too-many-sessions

# ~/.copilot/ 👀

# copilot-sessions

# …one more thing

Stop Putting Secrets in .env Files

# The problem with .env files

# Inject at runtime, never store on disk

# 1Password CLI

# Or macOS Keychain

# What you gain

# What about other tools?

# Try it

A Practical Guide to Writing with AI

# Why bother with a process?

# Step 1: Collect all your context in one place

# Step 2: Organize and find your story arc

# Step 3: Get the rough draft

# Step 4: The editing conversation

# Step 5: The voice memo trick

# Step 6: Human review

# Step 7: Publish

# The underlying philosophy

Securing My Home Network with AI

# The Setup

# Just Keep Talking

# The Project Harness

# NAS Hardening: The Fun Bits

# Documentation Just… Appeared

# My Favorite Artifact

# Why This Was Fun

# What’s Next

My First 30 Years in Tech

# The Foundation

# The Entrepreneur Phase

# The Pivot

# The GitHub Chapter

# The Realization

Turning Agent Misses into Systemic Improvements

# The Shift

# A Little Setup

# Turning Misses into Hits

# Example 1: Hallucinated GraphQL Fields

# Example 2: Stale Renders from Missing useSignals()

# Example 3: Test Harness First, Features Second

# Example 4: Visual QA Catches What DOM Assertions Miss

# What I Learned

# What’s Next

How I Work, 2025 Edition

# Two Mental Frameworks I Consistently Use

# PRIME

# SWOT

# My Workflow

# Why Markdown in VS Code?

# Optimizing Execution

# Walk → Think → Write

# Closing the Loop

# What’s Next

Building Career Security in an Uncertain World

# The Uncomfortable Truth

# Nothing is Guaranteed, So Always Be Preparing

# Build Relationships Inside and Outside Your Company

# Interview Every 1-4 Years, Even When You’re Happy

# Do As Much of Your Work in the Open as Possible

# Document Everything

# Analyze Yourself

# The Long Game

# The Reality of Failure

# What This Looks Like in Practice

# The Paradox of Preparation

# Back to My Friend

Designing Collaborations, Not Just Automations

# When Automation Delays Understanding

# The Breakthrough: Preserve Learning, Reduce Grunt Work

# Why This Matters Beyond Individual Tasks

Speaking with the agent

Audio triggers different brain pathways

Turning `say` into Relay

e-too-many-sessions

~/.copilot/ 👀

copilot-sessions

…one more thing

The problem with .env files

Inject at runtime, never store on disk

1Password CLI

Or macOS Keychain

What you gain

What about other tools?

Try it

Why bother with a process?

Step 1: Collect all your context in one place

Step 2: Organize and find your story arc

Step 3: Get the rough draft

Step 4: The editing conversation

Step 5: The voice memo trick

Step 6: Human review

Step 7: Publish

The underlying philosophy

The Setup

Just Keep Talking

The Project Harness

NAS Hardening: The Fun Bits

Documentation Just… Appeared

My Favorite Artifact

Why This Was Fun

What’s Next

The Foundation

The Entrepreneur Phase

The Pivot

The GitHub Chapter

The Realization

The Shift

A Little Setup

Turning Misses into Hits

Example 1: Hallucinated GraphQL Fields

Example 2: Stale Renders from Missing `useSignals()`

Example 3: Test Harness First, Features Second

Example 4: Visual QA Catches What DOM Assertions Miss

What I Learned

What’s Next

Two Mental Frameworks I Consistently Use

PRIME

SWOT

My Workflow

Why Markdown in VS Code?

Optimizing Execution

Walk → Think → Write

Closing the Loop

What’s Next

The Uncomfortable Truth

Nothing is Guaranteed, So Always Be Preparing

Build Relationships Inside and Outside Your Company

Interview Every 1-4 Years, Even When You’re Happy

Do As Much of Your Work in the Open as Possible

Document Everything

Analyze Yourself

The Long Game

The Reality of Failure

What This Looks Like in Practice

The Paradox of Preparation

Back to My Friend

When Automation Delays Understanding

The Breakthrough: Preserve Learning, Reduce Grunt Work

Why This Matters Beyond Individual Tasks

What AI Still Can’t Do

Climbing the Abstraction Ladder

New Metrics of Accomplishment

So What’s Next?

Conclusion

Too Many Meetings, Too Little Clarity

Why Transcripts? The Breakthrough

Proof: Fewer “Did We Decide That?” Moments

The Minimal Reproducible Stack

Advanced Moves

`fetch-github-conversation` — one-command context vacuum