Ryan Scott Brown

LLM Etiquette at Work

Wed, 10 Jun 2026 00:00:00 +0000

This post about the “slop grenade” got me thinking. New technology requires new social norms to go along with it.

TIL: Using Only One-Shot Agents

Tue, 02 Jun 2026 00:00:00 +0000

Models have gotten considerably better in the past year and my intuition for comfortably agent-sized tasks went stale. I now try to one-shot as much as possible by writing better prompts.

I have taken back my editor (it’s human-only now) and I don’t watch inference happen anymore. Agents go out into independent sandboxes (with --yolo) and work without input until it’s time to review and merge.

My new setup is:

Shuffle-Sharding's Evil Twin: Chokepoint Capital

Thu, 21 May 2026 00:00:00 +0000

Concentration risk is shuffle-sharding’s evil twin: an oligopoly of SaaS companies creating invisible choke points.

The Crowdstrike outage (nobody expects a blank file!) revealed a deep concentration risk among industries that follow similar compliance regimes: they want to be legible to auditors as being secure. How does one do that? Crowdstrike became a de facto monopoly not because it’s good, but because of a combination of enterprise sales, cargo culting, and similar CISOs swapping between similar companies.

Restarting Python Automation in 2026

Sun, 08 Mar 2026 00:00:00 +0000

A friend recently asked me to help them get started writing their own automations. I pointed them at Automate the Boring Stuff with Python, updated in late 2025 to cover Python 3.12+. This post covers a grab bag of techniques I’ve learned over the years.

The quickest start is my short post on using uv to manage single-file scripts to make standalone, machine-independent Python scripts.

Techniques

Think Like a Spreadsheet

The most useful mental model for data-driven automation is the spreadsheet. You have input cells (files, API responses, environment variables), intermediate cells (transformations, filters, lookups), and output cells (reports, deployed artifacts, notifications). When an input changes, only the cells that depend on it should update.

My Favorites from Re:Invent 2025

Fri, 02 Jan 2026 00:00:00 +0000

In the month since Re:Invent, I’ve put together my own greatest hits list of all the Pre:Invent and Re:Invent announcements. I missed Re:Invent in person, but sessions and announcements were put online almost-live. Sincerely, thank you AWS online events team that put together the live streams. Chalk Talks aren’t streamed, and were what I missed most.

My Top 5

1. The AWS CLI gets a revamp of SSO integration with the aws login command. It obsoletes most of aws-sso-util and awsume by bringing session-aware keys into the main CLI.

Revisited: Delegating Authority to Capricious Agents

Sat, 27 Dec 2025 00:00:00 +0000

Earlier this year I wrote a post about semi-trusting “agentic” development tools. My own workflow has evolved since, but container-use is still my favorite way to let agents work with minimal supervision and --dangerously-allow-all.

Since August, Opus 4.5 was released and included in Claude Code. This felt like a bigger leap than 3 to 4, or Sonnet 4 to Opus 4 for software development. The main change I noticed in my own usage was in how much more closely 4.5 adhered to specs like OpenAPI and JSON Schema. Tool usage also improved, instruction adherence seems better, and I have switched to using skills/ for everything except container-use and Playwright.

ID Structures: What's in a Name?

Thu, 11 Dec 2025 00:00:00 +0000

When building applications, mostly people think about entity IDs. Usually they are intentionally opaque: nobody wants users seeing auto-incrementing integers that reveal how many customers you have. Others, like ULIDs, trade away some opacity for sortability.

What about human-facing codes, ones users actually see and may need to share? Nobody thinks ahead about those.

Codes Are Everywhere

Think about all the places you need stable, human-friendly identifiers:

Error codes: RB2042: Invalid configuration gives your support team something to grep for and your users something to Google.
Discount codes: Marketing promo codes like SUMMER25 need to be flexible, but internally you want something that’s stable and could have many codes linked to it.
Product SKUs: Warehouse staff, customer service reps, and sales teams all need something they can read over the phone without wanting to die.
Feature flags: FF0042 beats enable_new_checkout_flow_v2_final_REAL when you’re debugging.
Ticket IDs: Jira and other task trackers use CT-0042 for tickets. The title can change as things become more clear, but commits, branches, and pull requests can be linked by the stable ID.

The pattern is the same: you need an identifier that’s stable, greppable, and doesn’t make humans sad.

Delegating Authority to Capricious Agents

Mon, 25 Aug 2025 00:00:00 +0000

I’ve been looking for a good way to be able to context switch less frequently when using tools like Claude Code and Github Copilot. So far one of my biggest obstacles has been the approval process. I want to come back to “complete” changesets to review and apply at my leisure, not stare at the model talking nonsense to itself.

Claude Code repeatedly attempting to replace the string z.string().datetime() with z.iso.datetime() and failing, resorting to calling itself silly and continuing to mix up the two strings.

In addition to not wanting to sit there and read the “reasoning” (read: LLM talking to itself), there’s a trust problem.

Carpe Access: AWS IAM for People & Systems

Wed, 20 Aug 2025 00:00:00 +0000

One rogue * can bypass security controls for an S3 bucket with petabytes of data if you aren’t paying close attention. AWS has 150 services and counting, apps need more external services and therefore granular RBAC. As engineers, we now have to worry about access for team members, LLM agents, and services we run. Managing the right levels of access is great for limiting the blast radius of a bug. Developers (and their agents) can’t ruin what they can’t change.

TIL: uv scripting and uvx

Sun, 29 Dec 2024 00:00:00 +0000

I’ve known about Astral’s uv and uvx tools for a while, but over the holidays break I’ve been working to streamline my setup and (if possible) simplify the tools I use.

Changing over to uv from pipx/pyenv/pipenv helps solve my accumulation of one-off scripts. Normally, when I write a script I make a new directory with a __main__.py, requirements.txt, the works. Now with uv I can keep all my one-offs in a single directory for reuse or reference while keeping dependencies reasonable.

Re:Explaining DSQL

Thu, 19 Dec 2024 00:00:00 +0000

DSQL is my favorite Re:Invent announcement in a while, and it feels like AWS returning to what it does best: foundational services that change the categories they exist in. Still, I don’t think AWS is selling it to developers in the right way.

I’m old enough (ow, my back!) to remember deploying before S3’s ubiquitous HTTP-connected object storage or dynamically provisioned EC2 instances. I was deeply excited (on this very blog) a decade ago for Lambda as a replacement for cron on a server.

TIL: Bot Detection & AWS WAFs

Sun, 10 Nov 2024 00:00:00 +0000

It’s been a while since I’ve had to pay close attention to WAF’s, and I still don’t love the maximum inspected body size of 8KB or Application Load Balancers and 64KB for API Gateway, CloudFront, etc. But there were a couple announcements this week that caught my eye.

First, CloudFront added JA4 Fingerprinting which I’d never heard of. It uses differences in each implementation of TLS libraries, you can take a fingerprint of the “HELLO” sent to start any HTTPS request and over time build lists of known-bad or known-good actors. Why use this? The hurdle for changing your fingerprint is at least somewhat harder than stripping session-id cookies, changing the user agent, and other browser-based fingerprints. For full details check out this article from Cloudflare.

Trying Out Typespec

Sat, 20 Jul 2024 00:00:00 +0000

My favorite part of working in GraphQL isn’t any of the runtime stuff. Applications I’ve worked on haven’t suffered from the over-fetching so commonly pointed to by GraphQL advocates as an inefficiency. Having a schema definition that is easily maintained and written without much of a learning curve is what makes GraphQL great. Recently I discovered Typespec, which has a familiar struct-like Schema Definition Language (SDL), decorators, and custom transformers. It also doesn’t require runtime application changes – you can use it for defining schemas without making any application changes.

TIL: Tauri Debugging Tools

Wed, 06 Mar 2024 00:00:00 +0000

I’ve been working on arsd support for multiple simultaneous AWS IAM Identity Center sessions, and found devtools by one of the Tauri project’s sponsors CrabNebula.

Devtools gives you a log viewer and waterfall graph interface for calls between the JS and Rust processes. I’ve found it helpful for tracking down UI hangs where the frontend is waiting on a worker.

How to run CDK CloudASM from a ZIP

Sun, 03 Mar 2024 00:00:00 +0000

For all my funsies projects (except the Rust ones), I use pantsbuild to build and deploy my code. It’s a great tool, and but its separation between artifacts requires that CDK code be run during the build step.

Artifacts that contain multiple files to be output in the pants package need to be archives. For my use case, I have a single Python file that builds every CDK stack and merges them into a single Cloud Assembly. For example, here is a simplified build file:

TIL: FoundationDB's Excessive Testing

Thu, 29 Feb 2024 00:00:00 +0000

An aphorism I’ve been feeling more every day is “slow is smooth, and smooth is fast,” and I found this post about the beginning of FoundationDB’s engineering journey.

Before we even started writing the database, we first wrote a fully-deterministic event-based network simulation that our database could plug into. This system let us simulate an entire cluster of interacting database processes […] driven by the same random number generator. We could run this virtual cluster, inject network faults, kill machines, simulate whatever crazy behavior we wanted, and see how it reacted.

TIL: ONNX Shortcut Models

Tue, 09 Jan 2024 00:00:00 +0000

Getting sentence-transformers to work in my llm environment has been a real pain, and I’ve been looking for a way to avoid the hassle. So I did a code walk of other projects that offer embeddings, and found that ChromaDB encountered the same problem.

They solved it by using an onnx format model automatically downloaded on the first use. See the code for yourself here.

TIL: Prompts Generating Prompts

Wed, 12 Apr 2023 00:00:00 +0000

Using ChatGPT I’ve started adding a tail onto prompts to generate better prompts. For example:

How might I set use custom metrics for my applications in AWS? Compare planning to use CloudWatch Embedded Metric Format (EMF), calling the CloudWatch API from my app, and using the CloudWatch agent.

Also, how could I have asked this better to get a clearer answer?

This gets a bit more out of the model, and I’ve found feeding the response back as a prompt has good results. Sometimes it misses the instruction for the suffix, and I haven’t found a pattern for that.

Book: Order Without Design

Sat, 13 Aug 2022 00:00:00 +0000

Alain Bertaud 2018, MIT Press

A city is the height of human acheivement, a way for humanity’s social nature to be concentrated into an efficient space while enjoying a good standard of living. The author of Order Without Design argues that urban planning can be improved by crossing disciplines between urban planners and economists. Cross-discipline collaboration is valuable because individual specialties can be blind to effects outside their legibility.

This book is packed with stats, especially about New York City and the ins and outs of zoning regulations there. The author starts from the assumption that cities exist for economic purposes: people live in cities for job prospects. Therefore, the city government should focus on facilitating economic activity in cities by maximizing the number of people who can afford to live within commuting distance of those jobs. From these initial assumptions, Bertaud focuses on maximizing density within the city (high FARs) and on ensuring commuters can reach the city from the suburbs quickly.

Book: There is no Antimemetics Division

Sat, 04 Dec 2021 00:00:00 +0000

qntm 2020

This book is extremely fun to read. You can get a free sample by reading the SCP-055 listing written by the same author. The core concept of the book is that there exist information with self-destructive properties. Information that, when learned, just slips out of your head.

The SCP Foundation exists to counter all sorts of world-threatening anomalies, including Antimemetic ones. The book is told as a series of vignettes, with characters recurring between them as we learn and unlearn things about antimemetic threats.

Git and Github Class Resources

Mon, 07 Mar 2016 00:00:00 +0000

Slides for this talk are adapted from the GDI official git curriculum. Upstream repo is here and my repo is here.

Additional Resources

Visual git cheatsheet (animated!)
Full reference manual
GitHub quick reference
Pro Git (published by Apress, available free online)
How to get out of a git mess
GitHub guides
Git command-line cheat sheet
Git-ready blog of tips & tutorials

Atreus: Sunrise Edition

Sun, 21 Feb 2016 00:00:00 +0000

Since college I’ve been interested in building better ways to type, and this weekend I took some time to build (yet another) keyboard. This one is the Atreus, a small ortholinear keyboard kit.

I’m not a big fan of the default Matias switches. I got an Infinity Keyboard from Massdrop and the attachment for the keycaps made it feel like I was at risk of snapping the PCB while putting them on, and I actually did break one switch while removing a keycap. The stem of the switches also have a lot of wobble when typing, so the board doesn’t feel as solid as my Ergodox, which uses Cherry switches. It’s also much harder to find keycaps with fun colors for Matias switches since they’re so much less common.

Keyboards and the State of Typing

Sat, 20 Feb 2016 00:00:00 +0000

Back in college, I read a great post on loper-os, Englebart’s Violin which I’m unlikely to do justice to here, but is definitely recommended reading. It focuses on the tools that humans use for potentially billions of hours each day: the keyboard and the mouse.

If you were to show the keyboard attached to your computer to a typist in the 1950’s, the most innovative piece according to them would be the apparently-magical light-emitting diode on the caps lock key (invented 1962). Everything else is the same: the key-per-character usage, the labels, the layout, even the plastics haven’t moved ahead all that much.

Using namedtuple with SQLAlchemy Core

Mon, 05 Oct 2015 00:00:00 +0000

SQLAlchemy is solidly in my top 5 favorite Python libraries, and has a starring role in many of my work and personal projects. OpenStack runs on SQLAlchemy.

The ORM in SQLAlchemy is helpful for projects with complex relations and logic, but when there are only simple data types SQLAlchemy Core is often all you need. I have a few pieces of data that map to a table easily, and relations aren’t important. For that case, the humble collections.namedtuple is invaluable. Declaring a namedtuple that matches column names is an easy way to add a little syntax sugar on top of SQLAlchemy Core without using the ORM.

Pomodoro: Feedback Loops Refined

Thu, 24 Sep 2015 00:00:00 +0000

Making a habit out of not just doing work, but doing the right work is critical to succeeding on a yearly basis. It’s easy to settle into a routine that makes each day look like a win on its own, but when you look back over the year you must be able to answer “well what did I do?”

Did you build a business from X dollars to X + Y dollars? Did you get (and figure out how to stay) in shape? Did you learn a skill? Did you get organized?

Choosing a Personal SLA

Wed, 23 Sep 2015 00:00:00 +0000

Email is absolutely a monster, and nobody loves their inbox. I certainly don’t, but it’s a critical communication medium and mailing lists are the life-blood of Open Source projects like OpenStack. Ignoring them is not an option.

I’ve tried to restrict email to certain times of the day in the past, but it’s never really stuck because it’s just so easy to leave your email client open all day and check in every so often. Part of the reason I failed so miserably to corral my email is because I felt like I had to respond to everyone as soon as I could.

Gollum as a Secure Personal Knowledge Base

Wed, 27 May 2015 00:00:00 +0000

After stumbling across gollum, I decided it was about time I started tracking things I find and learn in a more structured way. Especially tracking tasks I don’t do often.

My requirements were:

Must have search.
Plaintext. No specific data formats.
Ability to add to it from my ChromeBook.
Secure.

Gollum nails the first 3, with its beautiful web interface and git-backed markdown goodness.

So let’s start by going for 3-out-of-4. First, decide how you’re going to install gollum. I used rvm for the first pass, so let’s go with that. Get a shell as the user you want to be running gollum as, and let’s get going.

Git as a Presentation Tool

Sat, 16 May 2015 00:00:00 +0000

This past week I gave a talk on Flask at Python Buffalo with no slides. Not only did I skip slides; I made the whole presentation one big live demo application. Yes, I said to myself, tempt gods that would mock the hubris of the live demo.

Watching people type is booooring. Typos are about as interesting as a text-wall Powerpoint slide – which is to say not. To avoid exposing how poor a typist I am, I built the demo ahead of time and made a commit for each step. The repo looked something like this.

Declarative Orchestration: Lessons in Scaling Ops

Sat, 02 May 2015 00:00:00 +0000

Disclaimer: I work at Red Hat on OpenStack Heat, a declarative orchestration tool so of course I think they’re the way to go.

As more and more organizations move to cloud infrastructure instead of traditional physical or virtual systems, tools to handle large complex workloads are getting more important. The only wrinkle is that an operational system will tend towards higher complexity unless it is carefully designed.

Orchestration aims to make complex systems simpler to run by masking some of the complexity of actually creating all the pieces of a large application like: instances, DNS names, load balancers, databases, and private networks. Modeling all these in code makes management easier, changes more transparent, and are self-documenting ways to express interdependencies between your application’s infrastructure.

Deploying Hugo-Lambda

Thu, 26 Mar 2015 00:00:00 +0000

Last post, I announced the hugo-lambda project, a way to use a static site generator without actually running it. Since Lambda is just a developer preview, it isn’t the easiest to work with or debug at the moment.

To help with that, Mitch Garnaat has released kappa, a tool that streamlines the process pretty significantly. Each function gets a config file that defines its name, IAM roles, and event sources (triggers). With that information, kappa lets you deploy, test, and audit your function with a few simple commands.

An Overview of Hugo-Lambda

Wed, 25 Mar 2015 00:00:00 +0000

When Amazon introduced AWS Lambda I saw tons of interesting possibilities. Being able to react to events without needing to constantly run (and pay for) EC2 instances. I built hugo-lambda to take advantage of Lambda to rebuild my static site whenever I made a change.

If you’ve read much about lambda, skip this paragraph.

Lambda is still in an AWS (developer preview) product that consumes events from Kinesis (stream processing), S3 events, DynamoDB changes, and more. You can use it to make advanced materialized views out of DynamoDB tables, react to uploaded images, or archive old content. In short, you write a function (currently only in node.js) and it is presented with JSON containing information about the event’s source and content.

Let My Email Go

Mon, 05 Aug 2013 00:00:00 +0000

For a while, I’ve been looking to switch away from Gmail to maintain more control over my own data, especially something as critical as email. When looking for somewhere to switch, I had a few requirements.

Ability to transfer existing email to the new system (more on this later)
High reliability
SSL/TLS for IMAP and SMTP (read “security”)
Clear business relationsip. I had to be the customer, not the product.
Support for custom domains
Web interface (optional)

With all of these in mind, off I went on my search. Early on, Fastmail seemed like a clear winner. They had a mighty shiny web interface, custom domain support, and a good track record.

Redundant Split-Horizon BIND

Wed, 01 May 2013 00:00:00 +0000

There are certain topics in BIND9 that are well documented, like running a slave DNS server, or delegating a subzone. One of the least documented setups I’ve seen also happens to be one I had to implement.

I found myself in need of redundant split-horizon name servers behind a static NAT. I went through several iterations building this topology, and I learned something new at every step.

The topology would have three zones:

SpaceHub Follow-Up

Wed, 01 May 2013 00:00:00 +0000

Today is the day. It’s the deadline for Space Apps Challenge project submissions, and SpaceHub has a video submitted. Some of our wonderful colleagues at the FOSSBox helped us build a logo.

Our project is a way to bring together disparate codebases on Github. The challenge in question was to take all the different projects NASA has scattered across BitBucket, private Mercurial repos, SVN repos, and shudder tarballs and centralize them on Github.

Light Up The Dark Net

Sat, 13 Apr 2013 00:00:00 +0000

Last night I lit up my connection to Hyperboria which has been neat. Other than connecting, I haven’t done very much, but setting up cjdns was exceptionally straightforward. The hardest part of it was finding other users to peer with.

It seems to be a lot like what I imagine the early internet was like. There are a few peers and no real central authority. Names are assigned organically, and most seem to be on the network for experimentation. There are peers providing classic services like IRC and project mirrors as well as more modern services like a URL shortener and a reddit clone (Uppit).

Bash on Brass Balls

Sun, 07 Apr 2013 00:00:00 +0000

As a break from working on Panstora I wrote a silly app in a web framework I found. It’s called Bash on Balls, and the application I wrote is called Brass Balls. It’s a stupid web app that lets you mess with the computer that’s running it. Effectively, you make GET requests against it, and it runs arbitrary shell commands. It does all kinds of neat stuff.

It’ll alias vim to emacs, try to fill up your hard drive, and even attempt to “upgrade” your operating system to Oracle Linux if that can be said to be an upgrade.

Hack Upstate 2013

Sun, 07 Apr 2013 00:00:00 +0000

This weekend the FOSSBox sent a team to Hack Upstate, which drew attendees from upwards of 300 miles away. It was a very different feel than a lot of hackathons in Rochester, much more business- and design-type folks. Our team felt a little out of place as nearly pure programmers. This was pretty apparent during the pitches, which included farmers market awareness apps and WYSIWYG Wordpress plugin builders.

Our project is called [panstora] and it’s designed to provide a more online interface to physical stores. It’s built on Pyramid and SQLAlchemy. Users are supposed to use the app in stores to view more info about the item and to have the item delivered to them the same day, instead of buying items and carrying them home.

On Coding Standards

Thu, 04 Apr 2013 00:00:00 +0000

Yesterday I discovered a project under MediaWiki written in Python. The project is EventLogging that captures data about users as they interact with MediaWiki sites. On viewing the code, I noticed a couple of inconsistencies and out of curiousity asked where the MediaWiki code guidelines were for Python. They didn’t exist but for a single line in the MW:Code Conventions that mentions the PEP8 whitespace guidelines.

The folks in #mediawiki-e3 recommended that I be WP:BOLD and write some guidelines, so I did. The guidelines are PEP8, but in the article I pulled out a few of the more important points and added pieces of PEP257 to make a more clear docstring standard.

xkcd Hashing Challenge

Wed, 03 Apr 2013 00:00:00 +0000

On the 1st, the popular webcomic xkcd issued a hash-breaking challenge to universities. I didn’t find out about this until around noon yesterday (the second) meaning I was very, very late to the game. Especially in comparison to other competitors like CMU. When I began, RIT was below even the least of competitors. Even the laughable “fuckgoogle.com” was defeating us.

Fortunately, several hackathons this year have been giving out free Amazon Web Services credits. I decided to put mine to use for my alma mater. I spun up a total of 16 cc2.8xlarge instances, for a total of 512 cores. In the 12 hours I ran them, RIT was catapulted to 69th place with a hash distance of 386.

Microchord Chorded Keyboard

Sat, 30 Mar 2013 00:00:00 +0000

For some time I’ve had the idea that keyboards as we know them are terrible. I’ve looked at other keyboard layouts like colemak, dvorak, programmers dvorak, and so on. These are an improvement over qwerty according to some people, but it’s still the same keyboard that puts your hands in an exceptionally poor ergonomic positions.

So then you start looking to alternatives like a kinesis that lets you separate your hands, and save keystrokes by programming in your own macros. This is great, but you still end up moving your fingers a lot, and have a risk of adopting a pronating posture because the buttons still require lots of finger movement and are laid out parallel to your work surface.

Python Packaging is Hard

Sat, 16 Mar 2013 00:00:00 +0000

Conveniently after last week’s post on pythong I attended PyCon and was privileged to attend both the Python Packaging Mini-Summit and the Python Packaging Panel. This taught me a lot about the past and future of packaging in Python.

What I took away from the whole experience was “packaging is hard, lots of people want things, holy crap.” There’s the scientific community that needs to compile things like blas which is written in fortran. There are sysadmins that hate having to compile lxml on every machine they deploy on, web developers that need things to work on their Macs, and developers that want to deploy from version control seamlessly.

Python Project Bootstrapping

Tue, 12 Mar 2013 00:00:00 +0000

This is the introduction post for pythong a minimal, yet comfortable project bootstrapping tool. It’s intended to replace the now-unmaintained “paster create”. It will walk you through creating the project directory structure and prompt you for the information you need to build a good setup.py using the most recent packaging idioms.

This means distutils, first of all, and we built prompts to help walk you through the process of creating a distribute-based setup script.

RIT Week Numbers

Mon, 01 Oct 2012 00:00:00 +0000

Over the weekend I found a fun PHP form that will build week numbers (Monday-Sunday) for arbitrary date ranges. Using it to make a base of week number ICAL files for each of the RIT quarters, I made liberal use of Perl to convert from Monday-Sunday numbered weeks to Monday-Friday numbered weeks, and factored in RIT breaks. The ICAL file is available, and has week numbers for Fall-Spring of the 12-13 academic year.

Flash Drive Automation

Mon, 10 Sep 2012 00:00:00 +0000

Today I flashed over 120 USB sticks for IGIC conference happening at the Strong campus in Rochester. At first the task seemed daunting, but a quick script solved the problem of manual copying pretty handily, and a powered USB hub made it posssible to write to 9 drives at a time. Bash swoops in to provide a handy solution yet again.

Editing Remote Files With Vim

Tue, 21 Aug 2012 00:00:00 +0000

As you already know, Vim is a fine tool for editing files locally. Now, you can edit files on other machines. This is great for editing files on your webserver, or any other machine you have shell access to but don’t really want to SSH into.

vim scp://www.ryansb.com/var/www/html/index.html

This opens up a buffer on my local machine with the file from the remote machine, and I can save it and the new copy will be saved on the remote machine. Netrw supports FTP (ftp://host/name/of/file), SCP (scp://host/name/of/file), rsync (rsync://host/i/think/you/get/it/now), and many other common (and uncommon) protocols.

Fun With **kwargs

Wed, 21 Mar 2012 00:00:00 +0000

Ever want to write functions that flexibly receive arguments? What about getting defaults from a configuration on the module level, then have those defaults automatically used by functions in your module?

Well kwargs might be just what you need. “kwarg” is a nickname for “keyword arguments”, which you’re likely already familiar with in a format like this:

def func(first='ask questions', second='shoot'):
    print '{0} first'.format(first)
    print '{0} second'.format(second)

if __name__ == '__main__':
    func()

Let’s try it out!

ZSH+Boto Tab Completion for AWS

Sun, 26 Feb 2012 00:00:00 +0000

zsh is an awesome shell. It has enhanced tab completion features that go way beyond what you probably expect from a shell. If you don’t already use zsh but would like to start, this is a great place to jump in, it has everything you could ever want to know about zsh.

I use zsh as my main shell, especially for the revision control information in my prompt, appreciatively copied from the grml zshrc, 2700 lines of more than you need in a shell.

Distutils and You

Tue, 21 Feb 2012 00:00:00 +0000

Writing a python module is great, but what’s really important is getting it out to others so they can make use of it too. What’s the best way to do that?

Of course, the best way is to use existing infrastructure in the Python community. PyPI is the place to get Python modules. You can browse them on the web, and they are all just a “easy_install” or “pip install” away.

Ripkern Remote IPython Kernels

Mon, 23 Jan 2012 00:00:00 +0000

In lieue of using the standard Python shell, I have been using IPython and it’s been treating me very well. If you’ve never tried it, you can now try it online.

$ ipython
In [1]: print "hello there"
hello there

It adds some convienient features like tab completion, integration with your favorite editor, and “magic” functions that make your life easier.

One of the “magic” functions is “%time” for when you need to know how long an operation takes. The short of it is that IPython makes Python shells fun.