Site Map - skip to main content - dyslexic font - mobile - text - print

Hobby Public Radio

Your ideas, projects, opinions - podcasted.

New episodes Monday through Friday.



Host Image
Host ID: 78

episodes: 222

hpr2795 :: Dead Earth

Released on 2019-04-19 under a CC-BY-SA license.

Full shownotes are on

You can download Klaatu's update revision of the game materials here:

hpr2782 :: Never stop gaming

Released on 2019-04-02 under a CC-BY-SA license.

Shownotes are on

hpr2770 :: Navigating the maze of RPG books

Released on 2019-03-15 under a CC-BY-SA license.

Taxonomy of RPG-related books:

  1. Rulebooks tell you how to play the game.

  2. Optional books of rules add modular components to the base game. They add nuance to specific actions (for example, a book might add rules on owning and managing a castle in a fantasy world, or it might add rules on hacking in a sci fi game; these are things you can do without rules in the game, but if you want added stakes, then these books are ones you would want to obtain).

  3. Adventures (formerly called "modules") provide game plots and locations, in the event that you have no interest in designing your own.

  4. Source books or "settings" provide additional information on the setting of a game, sometimes even providing an alternate game universe with additional rules.

  5. Extra media, like novels, comics, movies, and video games, provide more information (sometimes in canon, sometimes not) about the game universe in which you are playing. Rarely do these have impact on the rules of the game, but they may provide a common language and shared experience for the players.

The only essential purchase is the rulebook. Everything else can be generated by gamers. Purchasing additional material is optional, and can either be seen as a great way to support a company providing your entertainment, or as an insidious plot by greedy corporations to rope you into a perpetual cycle of capitalism. However, RPG is a pretty healthy (and often open) system, so free and open content abounds.

hpr2766 :: Disk enumeration on Linux

Released on 2019-03-11 under a CC-BY-SA license.

The old way:

$ ls /dev/sd*

Another old way:

$ fdisk --list

An old way to see what you just plugged in:

$ sudo dmesg | tail

Some new tricks:

$ lsblk
sda      8:0    0   2.7T  0 disk 
├─sda1   8:1    0  23.3G  0 part 
└─sda2   8:2    0   2.7T  0 part 
sdb      8:16   0   3.9G  0 disk 
sdc      8:32   0 111.8G  0 disk 
├─sdc1   8:33   0   100M  0 part /boot/efi
└─sdc2   8:34   0 111.7G  0 part /
sdd      8:48   0   1.8T  0 disk 
├─sdd1   8:49   0   120G  0 part /var
├─sdd2   8:50   0   120G  0 part /tmp
├─sdd3   8:51   0    60G  0 part /opt
└─sdd4   8:52   0   1.5T  0 part /home
sde      8:64   0 298.1G  0 disk 
├─sde1   8:65   0   500M  0 part 
├─sde2   8:66   0 296.8G  0 part 
└─sde3   8:67   0   826M  0 part 
sdf      8:80   0 931.5G  0 disk 
└─sdf1   8:81   0 931.5G  0 part 
sdg      8:96   1   7.5G  0 disk 
└─sdg1   8:97   1   7.5G  0 part 

User-friendly udisks:

$ udisks --monitor /dev
$ udisk --enumerate | sort
$ udisks --mount /dev/sdc1
Mounted /dev/sdc1 on /media/mythumbdrive
$ udisks --unmount /dev/sdc1

hpr2764 :: Personal password algorithms

Released on 2019-03-07 under a CC-BY-SA license.

Here is a bash script to generate an org-mode word list matrix. It requires at least one file ending in .list to be used as a source of words or strings.


if [ -z $1 ]; then

cat >> "${DEST}" <<EOF
| | a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | x | y | z | ? |

VERT=(a b c d e f g h i j k l m n o p q r s t u v w x y z ?)

cat *list > tmp || exit

BIG=`wc -l tmp | cut -f1 -d' '`


while [ "$c" -lt "27" ]; do
    # horizontal row across
    v=`echo ${VERT[$c]}`
    printf "| $v |" >> "${DEST}"
    while [ "$n" -lt "27" ]; do
	i=`echo $((1 + RANDOM % $BIG))`
	w=`awk "FNR==$i" tmp`
	#reduce chance of empty cell
	if [[ -z $w ]]; then
	    i=`echo $((1 + RANDOM % $BIG))`
	    w=`awk "FNR==$i" tmp`
	    echo "blank cell found"
	printf "$w | " >> "${DEST}"
    echo " " >> "${DEST}"

/usr/bin/rm tmp

When you open the resulting file ( by default) in emacs, use the fill-paragraph (m-x fill-paragraph) function to align the cells into a pretty table.

Invent your own key, and generate some test passwords. Do this 6 or 8 times, and then try to reverse the key using the passwords and the table. If the logic to reverse the key is too simple, then try using values relying on the metadata, rather than data, of the table (for instance, the number of letters in the first word in the table starting with the same letter as the site name, or whatever).

Do you have analogue methods of generating passwords? Post ideas to either the comments or, better yet, as an HPR episode!

Here is a word list for testing:

hpr2763 :: Deepgeek explains SPF records

Released on 2019-03-06 under a CC-BY-SA license.

Klaatu reads a phlog (gopher) post by Deepgeek explaining the practical uses of SPF records.

hpr2757 :: How to DM

Released on 2019-02-26 under a CC-BY-SA license.


I've gotten a lot of great feedback on the Interface Zero play-through and the episode about getting started with RPGs I did with Lostnbronx. People have told me that one of the biggest blockers to getting started is knowing what to do as GM.

Now, I've read lots of rulebooks and GM guides, and it seems to me that most of them assume you've either played an RPG before, and so you've seen an example of a Game Master at play, or you've seen one on Youtube or Twitch. It's a safe assumption, but it's easy to forget all of those great examples under pressure. So in this episode, Lostnbronx and I are going to provide you with some clear and direct instructions on what exactly a GM does.

The short version is this:

  1. Tell the players where they are and what they see around them.

  2. Listen to the players when they tell you what they want to do.

  3. Tell the players the outcome, based on your privileged knowledge of the game world or on a roll of the dice, of their actions.

You loop over that sequence, and you're game mastering!

But that makes for a short episode, and anyway, there are details about the process that we can talk about to make you feel more comfortable with the prospect of deciphering a game world with your friends.

To that end, Lostnbronx and I have started a website dedicated to gaming! You should check it out, subscribe to our feed. We discuss everything game-related there, plus a little tech and all manner of topics of interest to geeks.


Right off the bat, it's important to understand that every GM is different. No two styles of running a game match completely, nor should they. And while there's no one correct way to run a game, there are plenty of ways to do it poorly. The GM wears many hats, but in my opinion, the most important job is to make sure that everyone has a good time. Your players are giving you an evening out of their lives. Next week they'll probably give you another. It's your job to make sure that time isn't wasted.

By definition, games, even role-playing games, are a form of entertainment -- like reading a book, watching a movie, or enjoying the circus. When you go to that, the GM is the ringmaster, presenting the show; while the players are both the audience, and the main attraction. The GM controls the world, the people, the monsters, the history, even the weather. The GM controls everything, in fact...except for the player characters. A game master presents the situation, but it's the players who decide what to do with that information.

Now, this is all pretty vague, and describing RPG's is far less informative than playing them. Considering this is a podcast, I encourage you to go back and listen to Klaatu's aforementioned "Interface Zero" episodes. These are excellent examples of actual game play. If you're having a hard time imagining how RPG's are presented and experienced, you'll appreciate those shows.

Now then, almost all games are divided into genre types: sword and sorcery; space opera; spies; super-heroes; and pretty much everything else. And I mean everything! If there's a genre of fiction and storytelling that you enjoy, chances are there's a game or game setting for it somewhere. The most popular style of RPG's out there are fantasy. Think "Lord of the Rings". Think "Harry Potter". Think of anything, in fact, because all of it is possible.

A staple of the high fantasy genre of gaming is the dungeon. Now, that term has two meanings in this sort of game: first, the usual meaning, of what amounts to the basement of a castle, with jails, interrogation rooms, storage rooms, and more. The other meaning refers specifically to a type of adventuring environment. Both of these are usually found underground, but an adventuring dungeon may have nothing to do with any castle. It might be a lost crypt, a cave system, an abandoned gold mine, or the lair of some dreaded beast that's been terrorizing the countryside. In the dungeon might be enemies, monsters, and treasure protected by deadly traps. Magic abounds. There might be puzzles, dark secrets, or a kidnapped prince to rescue.

As a new GM, you can start off any way you want, but in my experience, the best way to get used to how the game works, and how the whole process of providing an evening's entertainment to your friends or family works in this context, is to create a dungeon and run your players through it.

Dungeons generally require set-up time; that is to say, you have to design it in advance. Now, Klaatu and I are currently working on ways to ease that burden, with the ultimate goal of eliminating the pre-work entirely. But for now, let's talk about the traditional way to approach all this. What follows is a step-by-step process, but understand, it's only one of an infinite possible number of them.

STEP 01 -- CREATE THE COUNTRYSIDE Some GM's say creating the world is the first step. Some say creating the godly pantheons of the world is the first. Some say it's the history, or the fantasy races. They're not wrong, but trust me, when you're just starting out, none of that stuff matters. In this example, you'll be running the players through a dungeon. That dungeon is out in the country, within the middle of a large forest.

Now, it will make the beginning and end of the adventure easier if you have a small village nearby where the player characters all live. We'll call it Forestdale for the lack of anything better. In Forestdale, there's an inn or tavern. This is where people get together, tell tall tales, and become inspired to go adventuring, so let's give it a name as well: "The Prancing Unicorn". That's home base. Every player character knows this place, and everyone in it knows them.

One of the stories being swapped at "The Unicorn" lately is about a tribe of dangerous creatures living in an underground lair somewhere within the forest. They are led by an evil wizard, or so the tales go. They have been attacking farmers and merchants who travel through the roads and foot paths of the woods in order to sell their goods in Forestdale. One of the merchants says he saw them travel down the Western path near the Old Bridge. Something must be done, but who would be brave or foolhardy enough to even try?

And that's all you need to create for the world right now. Remember, this stuff is new; no one needs large amounts of detail just yet, least of all you. You'll have enough to juggle.

STEP 02 -- CREATE THE DUNGEON FLOOR PLAN One of the rumors to be heard at "The Prancing Unicorn" is that there's an underground cave system or labyrinth somewhere in the forest. Some say it's a myth, others say their cousin's uncle's sister's best friend came across it once. Either way, its existence is shrouded in mystery, and people are said to go in, but not always come out.

This is your first dungeon. You don't want to do more work than you need to. Let's make this dungeon a single level. Later, you can add a secret panel somewhere that can reveal a set of stairs down to a second level (and from there, a third, fourth, tenth, or more). Right now, it's one level, hidden below the forest. It's dark, it's dangerous. It's plenty.

Putting a dungeon together can be difficult, but it doesn't have to be. The traditional way to create one of these is to use graph or hex paper and draw out the floor map. Each square of the graph paper is equal to ten feet, or, say, three meters. You make note of all rooms, caves, doors, hallways, stairs up or down, floor traps, hidden doors, and anything else you want in there. Be sure to put a set of stone stairs that lead from the forest above, down to this dank and gloomy dungeon.

There are no standard symbols for the different things on the map, despite what anyone might tell you, but for now, let's turn the paper landscape style, and at the top of the page, now held that way, outline one square of the graph paper with a pencil. Inside the square, draw three or four small lines at an angle. This will represent a set of stairs. Next to the stairs, write the letter "U". This is the way to get to the forest above. Granted, it's how the player characters will come down here to begin with, but once they are here, they have to go up to leave, hence the "U". If that's confusing, you can write, "To The Forest Above", next to this square, maybe with a little arrow. You can write anything you want, but this is how the player characters will get in and out of your dungeon.

We're going to draw the floor plan from the top of the page down. The entire dungeon map will be on this one side of the paper. In the corner, draw an arrow pointing up, and put a letter "N" there. That's North. We'll be using compass directions from now on. Granted that when underground, it's hard to get your bearings without a compass, but for this first dungeon, we won't worry about that. North, South, East, West. It makes life easy.

On the bottom of the page, to the South, draw a box in the middle of the page that's ten by ten squares in size. This is where the dungeon tunnels all will be leading, and where we'll have the biggest fight of the adventure. We're setting that up now, so we always know where we're heading. Now go back to the stairs at the top of the page.

Draw a long line from the lower edge of the stairs going West. Stop the line a square or two from the edge of the paper. Now do the same thing going East. Next, move down one square, and draw another line parallel to both of these, going entirely from one side of the page to the other, East to West. You've just created a place for the players to explore, so imagine it for a moment: they come down some broken, forgotten stairs. Let's say they travel at least a hundred feet down, tripping over tree roots and walking through cobwebs, until the stairs deposit them in the middle of a dark tunnel, ten feet wide. It stretches to either side, running East and West out of sight (you know that it goes hundreds of feet in both directions, but you'll let them discover that for themselves). They listen, and can hear nothing but the scurrying of unseen vermin. At least, they hope that's what it is. Not a bad start.

Along this hallway, you'll draw little rectangles, like black bars, on random squares along the Southern side of the tunnel. Not too many, just a few here and there, with generous space in between. These are heavy wooden doors. Some may be locked. That's your choice. If they are, put a little symbol near them. It could be as simple as the letter "L", so let's go with that. Now you know where the all doors are in this particular tunnel, and you know which of them will be a challenge for the player characters to open.

This is just the first tunnel of a larger complex. This complex can be as big or as small as you'd like. Let's say it's moderately sized. Before we draw more tunnels, let's draw the rooms behind those doors. This will tell us how much map space we'll have for further tunnels. Some GM's like to draw all the tunnels first, and then fit in the rooms. You can do it however way you want later on; right now, let's just use this method. Pick a door. Draw a box behind it, three or four squares in size. That's the room. Do the same behind the other doors. Make the rooms different shapes and sizes, but not too big. Let the big room at the bottom be the star. When you're done, you have a huge tunnel, with several mysterious doors, behind which are some good-sized rooms.

On the part of the tunnel that ends on the West side, draw a connecting tunnel South for five squares, and then turn the direction back to the East. Draw this tunnel going that way for ten squares. Put a door or two along here, and draw some rooms for them. Turn the tunnel South again, and go five or six squares, and turn it East again for four squares. Draw a door and room. Maybe it's locked, maybe not. Continue with this meandering, jagged floor plan, wandering East and then West, but always moving South. Add occasional doors and rooms as you go, until your tunnel finally ends on the Western side of the large ten by ten square room at the bottom of the page. Draw a door to get in there.

Now go back up to the long tunnel at the top, and repeat this whole process on the Eastern side, eventually bringing that part of the tunnel to the Eastern edge of the big room at the bottom. Put a door there.

Now, number your rooms on the map, starting at at the top, and working your way down, until you've marked each one. Room numbers are essential, because you'll be keeping track of each one.

The floor plan to your first dungeon is complete. Now you need to put interesting things in it.

STEP 03 -- POPULATE YOUR DUNGEON Okay, on a separate piece of paper, list the rooms of your dungeon. Start at #1, and go down. Beside the room number, you put in a brief description, along with any monsters, treasure, or other points of interest. You'll be consulting this list throughout the game, so write down everything you need to know, in order to minimize the amount of time you'll inevitably have your nose in the rulebook while playing. Monster statistics, including their weapons, and and the damage they do, should all be on this list, though there are ways to simplify the process, once of which I'll go into in a moment.

When putting creatures and things into your dungeon, the first thing to remember is to not overload it. Each room does not need a monster. Not every room needs treasure. It might be helpful to think in terms of what you'd like to see in the dungeon as a whole. Remember the stories of evil creatures, and possibly a wizard, which you heard at "The Dancing Unicorn"? We'll use that as our springboard. This is a starting dungeon, not just for you, but also for the player characters. Starting dungeons mean low-level monsters, so let's go with goblins.

Goblins are generally quite impressed with magic, so we're going to assume a wizard of dubious character has bullied a small tribe of them into being his thugs. They've been waylaying passing merchants and farmers, stealing their wares, and carrying off food (along with the occasional peasant worker, as goblins love the taste of human flesh). Stupid, but dreadful creatures, they have displayed a level of tactical organization that's not normal for them. This, of course, is because the wizard's in charge. Look up the statistics for goblins, and understand what they're like. For this adventure, we're not going to worry about goblin captains, or goblin chiefs, both of which are tougher than your average goblin. No, all the creatures for this adventure have the same statistics. Don't drive yourself crazy writing them down, over and over. Write them once at the bottom of the room description page, and every time the player characters run into a goblin, consult them.

Let's say there are a total of fifteen goblins in this dungeon. They won't all be together; the player characters will encounter a few of them here and there, in various rooms, or maybe ust wandering the tunnels. The rooms themselves will have the spoils of all their raids, including barrels of wine, hams and sides of beef; furs, and a few copper, silver, and gold coins. If there's wine in one of the rooms, maybe the goblins there are drunk, fighting at a penalty to hit and damage. And remember, not all rooms need things in them. Maybe this was once a temple, and there's just broken furniture, and rotting religious robes in some of the rooms. In one, there might also be a tapestry against the wall, depicting a miracle of whatever god this place was once dedicated to. What you might not tell the player characters up front is that the tapestry could fetch a fair amount of gold coins in the market back in Forestdale. Too big to carry while exploring the dungeon, such a thing could always be rolled up and fetched on their way out. Not all treasure is found in wooden chests.

Then again, a lot of it is, so why not put one in the big room to the South? Of course, you have to defeat the evil wizard and his goblin cohorts, wh are hanging out in there. As a rule of thumb, you might want to sprinkle half the goblins throughout the dungeon, leaving the other half here, for the final fight. Stealth matters. Approaching the big room noisily, and kicking open one of the doors, is not stealthy. The player characters might be able to catch the wizard and his minions off-guard, if they move quietly.

In order to be a credible threat to the player characters, this wizard should be of a slightly higher level, say 2nd or 3rd. He'll have some aggressive spells, and he'll have his goblins handy. You'll roll up the wizard the same way the players rolled up their characters, only you'll make him more experienced, and with more spells at his command. Maybe he even has a magic item of some sort. Should the players defeat this guy, this magic item will be part of the treasure; until then, it's something the wizard will use against them. Don't make it too tough. Maybe don't make it tough at all: a +1 Ring of Protection, maybe. Or perhaps, a +1 dagger. That might not sound like much, but it's more than the player character's have when they start.

Not enough excitement, maybe? Just add in a couple of giant rats in one of the rooms. Maybe some large spiders in another. Don't forget to put their statistics down in the room description. Judging how tough or easy a dungeon needs to be comes with experience. My suggestion is to err on the side of toughness, to put more challenges in there than maybe you feel comfortable with. If the player characters are looking depleted and injured, you can say the room is empty, instead of filled with spiders. Also, it doesn't hurt at all to remind the players now and then that it's okay to retreat. They can always come back another day when they're rested, and have made plans based on the knowledge they gained the first time around. It sets up a grudge match...the heroes vs. the evil wizard and his goblin hoard. You, as the GM, just repopulate the goblins, move them around a bit, so they're not all in the same rooms as before (though the big room should still be for the final fight), and //voila//! You've just provided your players with two night's worth of entertainment, for the effort of only one.

And there you have it: a stocked dungeon that dovetails into the local lore of the countryside, ready for your players to explore.

STEP 04 -- ROLLING UP CHARACTERS Some GM's will want a whole night just for this process. Others will just have the players arrive at the game with their characters ready to go, especially if they are experienced with the game. I won't go over the character creation process here, because each game is different, and some are VERY different. I mention this now, though, because the players need characters, and creating them comes before the adventure starts. If the game is as new to them as it is to you, take that whole night to help them create their characters. It's fun all on its own, and it allow's everyone to be familiar with the other characters -- something vital to party survival.

I'm not going to go into detail about the process of rolling up characters, because, like you, Klaatu and I have dedicated an evening just to this process. In a previous episode in this mini-series, the two of us created a character from the ground up, so you can hear what's involved, and how you might want to approach the process with your own players.


If designing your own custom dungeon seems intimidating to you, there is another way. And it's a time-honoured, legitimate way to play, and it's quite often the way I play: you go find an adventure that someone else has already written.

An adventure is the scenario you and your players experience when you sit down at the table to play. It's arguably the *game* (the rulebooks are the game engine, or the mechanics). Wizards of the Coast, Paizo, Catalyst, Kobold Press, Frog God, and many others publish adventures (sometimes called "modules", "scenarios", or "adventure paths") written by professional game designers. Published adventures provide the story framework for your game.

Not all systems publish adventures, though, or you may choose not to use one. If that's the case, spend some time developing a story. Writing a good game is part science, part craft, and part magic, but if you and your players are up to the challenge, then running blindly through a story that's mostly being created spontaneously on the spot can be a lot of fun. If that sounds overwhelming, though, get a published adventure!

Quick tip: Free, small, or introductory adventures are often available from,, and

Many adventures have text blocks that provide you with introductory text for each part of the game, they explain clearly what the goal of the players is during that segment, and give you guidance on what players will find in the area and how those discoveries lead to the next plot point.

Broadly speaking, there are two types of published adventures: there are "one-shots" and there are "modules" or "adventure paths".

A one-shot adventure is analogous to a quest in a video game: it's a single, clearly-defined task with a very obvious and immediate result; for example, goblins are terrorizing the hapless citizens of the local village, so go to their cave and clear it out: if you do, you'll relieve the villagers of the horrors, and you get to keep any gold or weapons you find.

The advantage is that it's designed to be a quick, one-time game session, so it's perfect for playing with friends you only see once in a while, or with someone who's never played before and just isn't sure if it's something they want to commit to. Don't be fooled by the page count of these small adventures: it may only be 5 to 10 pages long, sometimes less, but you'll be surprised at how long players can spend exploring a boundless world existing only in their imagination.

Adventure paths or modules or campaigns are bigger stories with loftier goals. You can think of them as lots of little one-shots strung together so that once players accomplish all the tasks and solve all the mysteries over the course of 200 pages, they have a final showdown with some Big Bad, and win themselves a place in the legends of the game world. It's an epic poem instead of a short story. It feels grander, it feels important. The losses along the way are more profound, and the victories sweeter. These campaigns take months to play through and usually expect a gaming group to meet weekly or fortnightly or at least monthtly to work their way through the tale.

I should mention one more kind of book you might stumble across, and those are source books. I mention this because I've had friends go and buy books more or less blindly, and then they bring them back home disappointed that instead of a book of lore about dark elves, they bought an adventure set in the underdark. Or the other way round: they wanted an adventure and ended up with a rule book.

This happens with the bigger systems that produce a lot of media, like {D&D, Shadowrun, Pathfinder, Warhammer}, so get clarity on what you're buying before you make a purchase. If you come across a cool ShadowRun book called RUN FASTER expecting a campaign to run with your friends, you'll be surprised to find that you've purchased a source book full of metatypes, expanded rules, and alternate character creation methods: sort of a Shadowrun Core Rulebook part 2. Same goes for, say, Volo's Guide with D&D, or Ultimate Campaign in Pathfinder. It can be overwhelming and they're not aways labelled clearly (or if they are, the label gets lost in the word cloud of RPG jargon that you're not used to yet), so do a little research first.

I've played through dungeons that a GM created over his lunch break, and I've played through adventures written by clever game designers, and I can confidently say that they're both great ways to RPG. But as a GM, if you feel overwhelmed by the idea of designing a dungeon, a published adventure is a great way to start. Aside from reading a chapter ahead before each game night, all the prep work is done for you, and there's very little thinking required.

Another part of being GM is deciding when a die roll is necessary. Die rolls represent the chance of success or failure when a specific action is taken, but the confusing thing is: if you think hard enough about anything in the world you can find a chance of success or failure. As a GM, it's up to you to decide what's "important" enough for a roll. Strictly speaking, that's determined by the rules. The rules told you what requires a roll, and you're expected to know the rules well enough to make the call.

In practise, however, you have a lot of stuff to track in you head, and remembering what requires a die roll, or deciding to request a die roll even though it may not be strictly required, can feel overwhelming for a new GM.

Good news: Players intuitively know when to roll dice. A player knows their character's skills (because they built the character and wrote it down on their character sheet), so sometimes the actions they choose to take are chosen because it falls within a category of a skill they happen to have. A thief probably wouldn't ever think to *look* for hidden door if the thief were a fighter (who would more likely think to pound on the wall rather than to slyly look for a hidden door). So if your player reaches for dice, let them roll because they're probably right.

I'm sure it's possible to take it too far, but people like to roll dice. It's part of the fun of an RPG, the uncertainty of subjecting yourself to the whims of fate. So when in doubt, either make your players roll dice, or roll dice yourself. I use dice rolls to help me decide everything from NPC reactions to weather conditions. It's usually safe to default to rolling.

Worst case scenario is that die are only picked up for fights and a literal interpretation of skills: and that works because those are the rules as written.


Players drive the story. In video game or movie terminology, they control the "camera". When players are exploring or investigating, let them ask questions or take actions ("I look in the closet"), and answer them as you see fit ("You open the closest and see an array of fine garments.")

"I'll move the clothes aside and examine the walls, and the floor. I'm looking for trap doors or hidden compartments, or anything suspicious."

And so on. Players can choose to investigate and explore for as much as they want. That's the beauty of a pen-and-paper RPG: the world is infinite. That said, you're the GM and you owe it to your players to keep the game moving. You don't to let your players spend 3 real hours searching a room that, in the end, has no bearing upon the plot whatsoever. That can be a delicate matter, because the nature of the game means that you know things that the other players don't, meaning much of the puzzle for players is what they don't know.

Usually I let players explore a space on their own until I feel that they've explored the obvious parts of it, and then I remind them where the exits are, or I remind them how many other rooms there are to explore, or some subtle clue to say, without saying, that they've secured an area.

If players are especially suspicious of something, though, you certainly have the power to generate a subplot, and often times you should do that. It's fun for you and rewarding to players. For instance, if a player is convinced that there's a secret panel in a closet and spends a lot of time investigating, then you might decide that there IS a secret panel in the closet, and then roll on a random table to determine what could possible inside that compartment. Or you could leave the compartment empty, thereby creating a story hook to return to later...what used to be in that compartment? who took it, and why? What were the implications?

Keeping the gaming moving is an inexact, unscientific process, but usually it comes pretty naturally. When you start to get bored of the players exploring, you can bet that they're probably getting bored too, and that's when you know to urge them forward. If all else fails, you can always have something lure them from one space to another: a mysterious sound, an oncoming threat, or a supernatural or divine instinct.

hpr2749 :: Lostnbronx and Klaatu commentary from episode 2743

Released on 2019-02-14 under a CC-BY-SA license.

Out-takes from episode 2743. This is commentary about modern RPG play style, the character build process, Starfinder as a system, and more.

Did you know that Lostnbronx and Klaatu have a gaming blog? We do! You should go subscribe to it at

The blog features commentary about gaming, tech, geek culture, a podcast or two, and lots more.

hpr2743 :: Character build in the d20 system

Released on 2019-02-06 under a CC-BY-SA license.

Klaatu and Lostnbronx spend an hour building an RPG character at a leisurely, and hopefully informative, pace. While the build process here is technically specific to the sci-fi (or science fantasy, really) game Starfinder, the idea is to convey the generic process of stepping through a character build instruction, cross-referencing important rules, and generally learning how to build a character in an unfamiliar system.

hpr2732 :: Storytelling formula compliance

Released on 2019-01-22 under a CC-BY-SA license.

Storytelling has had a formula for yearsAndYears. Some people speak of it in disdain ("it was too formulaïc") and others (creative writing and intro film teachers, mostly) praise it. Everybody else (us) is a sucker for it.

Here is the literal formula, in pseudo code:

{A} Reinforced


{A} Returned


{Z} Returned

You can (and should, because it's free and you can throw out your work if you don't like it) practise this formula by plugging in events to represent A and Z, where A and Z are polar opposites.

Really obvious examples are any given romantic comedy:

{A} Jack is A="single and free"
{A} Scene to reinforce that Jack is in relationships with no strings attached. Jack is {A}.

{Z} Jack meets Jill, realises she makes him happy. He decides he's had enough of being {A} and want to be {Z=married}

{A} Reunion with old school mate makes Jack question his resolve. He leaves Jill so he can be {A}

{B...Y} Plot happens. Jack does stuff, Jill does stuff. Funny? Tragic? You decide!

{Z} Jack realizes at last that he's only happy with Jill, and that being {Z} with Jill is the only way to be truly free.

You can also try it with the old Evil Empire plot line.

{A} Jill is an {A=obedient citizen}. Loves her mama, loves Jesus and America, too.
{A} Scene in which Jill witnesses a Rebel being mistreated unjustly, but does nothing to stand up for what is right, because she is {A}.

{Z} Jill meets Jack, an outlaw and rebel against the Empire. He's in trouble, so she helps him evade the police.

{A} Jill, horrified at her own rebellion, conforms all the more. She is dedicated to the Empire, and works diligently to hunt down Jack and his rag tag band of rebels.

{B...Y} Plot happens. Action, laser guns, laser swords, nationalism, motorcycle gangs.

{Z} Jill, seeing the devastation her allegiance has caused, realises that the Empire is actually Evil. She joins the rebels to fight for freedom.

Now go practice this. Soon you will be telling stories, jokes, and anecdotes that have a clear beginning, a clear conflict, and a clear ending.

hpr2725 :: The Illumos Shutdown Command Explained

Released on 2019-01-11 under a CC-BY-SA license.

In response to JWP's episode 2697 and ClaudioM's comment, this show covers the shutdown command as it appeared in Sun Solaris and OpenSolaris, and currently appears in both Oracle Solaris and OpenIndiana.

The quick version:

  • shutdown
  • -i sets the destination init state (5 to shutdown, 6 to reboot, and so on; see man init for more)
  • -y to answer "yes" to the safeguard prompt asking you whether you really want to shutdown
  • -g to set how many seconds until shutdown. Default is 60.

In practise, I don't even use the shutdown command. I use poweroff, which does a shutdown and poweroff.

Both shutdown and poweroff require root permission. On OpenIndiana, you can either use sudo bash or pfexec bash to get a root prompt.

Some links:

OpenIndiana handbook

Sun Microsystem docs (with Oracle branding on it)

hpr2712 :: Steganography

Released on 2018-12-25 under a CC-BY-SA license.

Did you find the hidden message contained in Klaatu's previous two episodes?

If not, Klaatu reveals how to find it in this one, how to duplicate it, and what makes good steganography.

hpr2708 :: Ghostscript

Released on 2018-12-19 under a CC-BY-SA license.

Ghostscript is the open source implementation of Postscript. You can read its docs online.

To compress a big PDF into something possibly smaller:

$ gs -sDEVICE=pdfwrite -dCompatibilityLevel=1.4 -dPDFSETTINGS=/screen -dBATCH -sOutputFile=output.pdf example.pdf

That renders basically the same PDF with all images down-res'd to 72 DPI. Other valid setting profiles are ebook, printer, and prepress.

To render a version of a PDF without any raster images in it, making it cheaper and faster to print:

gs -sDEVICE=pdfwrite -dCompatibilityLevel=1.4 -dPDFSETTINGS=/screen -dBATCH -dFILTERIMAGE -sOutputFile=output.pdf example.pdf

The FILTERIMAGE option drops raster images from the file. The FILTERVECTOR option filters vector images, and FILTERTEXT filters text.

If pdftk is not available for your OS, you can use pdf-stapler instead for cutting and concatenating PDF files. It doesn't deal with metadata as well as pdftk does, however.

It's worth noting that pdftk is available as a snap package

It's also worth noting that this is actually episode 2 in a series about steganography.

hpr2704 :: Intro to Scribus

Released on 2018-12-13 under a CC-BY-SA license.

Scribus is a page layout application. If you are familiar with common publishing industry tools, then Scribus will be very familiar to you, but if you're used to word processors or graphic applications, then Scribus will probably confuse you. In this episode, Klaatu talks about the workflow of page layout, and how to do some basic tasks in Scribus.

The example files Klaatu produces in Scribus are available at

Fair warning: this episode is actually "about" steganography. The key you need is OGG.

hpr2672 :: Porteus

Released on 2018-10-30 under a CC-BY-SA license.

Porteus is a portable Live Linux distro, based on Slackware, intended for use on thumbdrives or optical media. It is, more or less, the new Slax, now that Slax has switched to Debian.


The official means of installation is to burn Porteus to disc, and then (optionally) install Porteus onto a thumbdrive from within Porteus. To install Porteus to a thumbdrive, you need a thumbdrive with an EXT4 partition. You can try other filesystems and partition schemes, but EXT4 definitely works well.

From either Porteus or Slackware (you can try other distros, but results will vary), you can do a manual install, and here are the correct commands (as of this writing, the docs on are not accurate). Assuming you have discovered, using lsblk, that your target device (the thumbdrive) is /dev/sdx:

$ sudo bash
# mkdir -p /mnt/loop /mnt/drive
# mount --options loop /path/to/Porteus*iso /mnt/loop
# mount /dev/sdx1 /mnt/drive
# rsync -av /mnt/loop/ /mnt/drive/
# cd /mnt/drive/boot
# chmod +x
# ./Porteus*com

Alternately, you can use Porteus from a virtual machine and install to a thumbdrive, as long as your virtualisation software redirects USB. I have used virt-manager running on Fedora successfully for this.

The other alternative, of course, is to run Porteus off of an optical disc. That means your system is unwritable, so nothing you do is persistent across reboots, but you can save your work to a thumbdrive. I've worked with Slax this way before, and it's quite manageable.


Booting to Porteus depends a lot on the firmware of the computer you're booting. Almost every Linux distro in existence has accurate docs on the changes you may or may not need to make to your BIOS or [U]EFI in order to boot to Linux, so you can find more detail on this if you need. Here's some text I borrowed from Linux Mint:

Insert your USB stick (or DVD) into the computer.

Restart the computer.

Before your computer boots your current operating system (Windows, Mac, Linux) you should see your BIOS or UEFI loading screen. Check the screen or your computer’s documentation to know which key to press and instruct your computer to boot on USB (or DVD). Most BIOS or UEFI have a special key you can press to select the boot device and all of them have a special key to enter a configuration screen (from which you can define the boot order). Depending on the firmware, these special keys can be Escape, F1, F2, F8, F10, F11, F12, or Delete. That information is usually briefly displayed on screen during the boot sequence.

On Macs, keep your finger pressed on the Alt or Option key after hearing the boot sound.

Boot modes

Porteus can boot to its default persistent modes: graphical or text. Both of these modes auto load any Porteus modules you've installed and also read any changes you made since the previous boot.

It can also boot to ephemeral modes: Copy to RAM and Always Fresh. These modes act as if you've never booted into Porteus before, loading a completely fresh version of the file system. They also do not load Porteus modules automatically.

Installing software

Porteus modules are Slackware packages converted to .xzm files, a highly-compressed SquashFS filesystem. When a Porteus module is activated, the application and other files contained in the module appear in your environment. You can think of it as a layered filesystem.

To install software, you must sync up your package manager with upstream repositories:

$ sudo usm -u all

Once everything is updated, you can search for packages using the -k (for keyword) option:

$ sudo usm -k foo

And then install it:

$ sudo usm -g foo

You are prompted to either install or download the module. If you install it, then it becomes part of the filesystem. However, since changes to the filesystem are NOT read by the Copy to RAM or Always Fresh modes, this is probably not what you want. Instead, download the module so that you can have Porteus load it dynamically regardless of what mode you're running.

Modules are downloaded, by default, to /tmp/usm/ and then converted from their native format of .t?z to .xzm files. You can copy the .xzm files to an external device if you're running off of optical media, or into a persistent area on the thumbdrive running Porteus. Modules can be made permanently available in the /mnt/sdx1/porteus/modules or /mnt/sdx1/porteus/optianal directories.

Modules in the ../modules path are loaded at boot in the Graphical and Text modes, and are available to load manually in the Copy to RAM and Always Fresh modes.

Modules in the ../optional path are never auto loaded.

Modules can be activated or deactivated with this command:

$ sudo activate foo


Flatpak works on Porteus, too. I have found this to be convenient for applications like GIMP and Inkscape and Kdenlive and many others that are complex enough to warrant special attention.

Flatpak does require the glib-networking package. You will not be warned about this, because all upstream Slackware repositories assume a full install of Slackware (and glib-networking is included on Slackware, but not on Porteus). Once you install glib-networking, you can use flatpak as described, for instance, on the GIMP downloads page.

Over-customizing the "hard-coded" parts of Porteus is unwise. For instance, keep the default user (guest), don't try to change the UID (I tried and failed), and so on. Treat the system, more or less, as if though you were a guest on someone else's multi-user system. Install and customise stuff locally and through modules when possible. That's what Porteus expects, and things can break if you try to treat it too much like a traditional Linux system.

hpr2667 :: Create PDF bookmarks with Pdftk

Released on 2018-10-23 under a CC-BY-SA license.

Pdftk is a command that lets you manipulate PDFs outside of a GUI PDF creation tool. There are several GUI tools you can use to create PDFs with valid bookmarks and other fancy features, but pdftk is often more convenient.

Extract pages 1 through 2, and pages 5-21, and page 261 from a big PDF into a new PDF:

$ pdftk big.pdf cat 1-2 5-21 261 output small.pdf

Extract bookmarks from original PDF:

$ pdftk big.pdf dump_data output book.mark

Here is what a bookmark file looks like:

InfoKey: ModDate
InfoValue: D:20181010181951-05'00'
InfoKey: CreationDate
InfoValue: D:20181010181934-05'00'
InfoKey: Creator
InfoValue: pdftk (Linux)
InfoKey: Producer
InfoValue: pdftk 2.02-x86_64
PdfID0: d8deadbeeff34211ba60d80fda7611da
PdfID1: 39186170c6134566884b79c0ffee7d59
NumberOfPages: 261
BookmarkTitle: Cover
BookmarkLevel: 1
BookmarkPageNumber: 1
BookmarkTitle: Credits
BookmarkLevel: 1
BookmarkPageNumber: 2
BookmarkTitle: Chapter One
BookmarkLevel: 1
BookmarkPageNumber: 3
BookmarkTitle: Foo Section
BookmarkLevel: 2
BookmarkPageNumber: 5
BookmarkTitle: Bar Baz
BookmarkLevel: 3
BookmarkPageNumber: 7
BookmarkTitle: Back cover
BookmarkLevel: 1
BookmarkPageNumber: 19

Apply the bookmark data back to the PDF:

$ pdftk small.pdf update_info book.mark output final.pdf

hpr2638 :: Dirt cheap Magic

Released on 2018-09-12 under a CC-BY-SA license.

In this episode, Klaatu talks about playing Magic: The Gathering for cheap.

See by Eric Jome for a good deck building formula.

hpr2634 :: Git tag and metadata

Released on 2018-09-06 under a CC-BY-SA license.

Tag a commit:

$ git tag 0.1
$ git tag

Delete a tag:

$ git tag -d 0.1

Get the latest commit hash:

$ git rev-list --tags --max-count=1

Get any tag on a commit:

$ git describe --tags 94c5715

hpr2613 :: Quick Awk Tip

Released on 2018-08-08 under a CC-BY-SA license.

This is obvious, but it tripped me up a few times after listening to the excellent Awk series by Dave and B-yeezi, so I though I'd share it here to save others the trouble.

When moving from simple awk commands to proper awk scripts, you put a shebang line at the top of your script. It's pretty common to many of us, because we do it for Python and Bash all the time.

But if you just put:


Then your awk script won't work the way you expect.

You must provide the -f flag:

#!/usr/bin/awk -f

Now you can pipe things to your awk script as expected.

hpr2609 :: SparkleShare

Released on 2018-08-02 under a CC-BY-SA license.

Clacke mentioned SparkleShare in episode 2542, and it occurred to me that not everyone knows what Sparkleshare is. So here's a show about it.

To setup SparkleShare, refer to It's available for Linux, Windows, and Mac; great for cross-platform collaboration.

The Linux installer uses FlatPak, so you do need to install that.

Once installed, launch SparkleShare in the usual way. If you have no usual way, you can use this command:

$ flatpak run org.sparkleshare.SparkleShare

The first screen asks for your name and email. This doesn't have to be your real name and email, but it is what SparkleShare will use when making commits on your behalf. This name and email will be visible to anyone who can see your online Git repository.

The next screen displays the Sync Remote Project screen. You use this screen any time you want to add another share to your sparkle.

image showing the Sync Remote Project window of SparkleShare

In this episode, I set up two projects: one brand new one using my home server as host, and one that mirrors an existing project on

Adding a project from Gitlab

The first thing you must do is give SparkleShare permission to access Gitlab. To do this, click on the SparkleShare icon in your system tray > SparkleShare > Client ID and copy your ID to your clipboard.

image describing the menu selection as listed in the above text

Now go to your online Git host and add this "Client ID" to your approved SSH Keys. Where this is located depends on your Git host, but in Gitlab, it's located in the left column of the Settings screen. When your SSH Key has been added, Gitlab displays a key fingerprint (actually just a string of numbers) as confirmation.

The path to your remote Git repository is the part of an URL after the host. It usually starts with your username. For example, if I have a project on Gitlab located at then the path that SparkleShare needs is notklaatu/foo.git

Click the Add button to add the project to your local SparkleShare folder.

Adding a project hosted on your own server

There are a lot more variables if you're hosting a Git repository on your own server. These are the things that you may need to account for:

  • Is your local .ssh/config file setting some "invisible" defaults for when you SSH to your server? If so, you may need to modify or add an entry for SparkleShare.

  • Your SparkleShare auto-generated "Client ID" is located in $HOME/.config/org.sparkleshare.SparkleShare/ssh

  • Is your SparkleShare SSH key (the "Client ID" in SparkleShare lingo) in your authorized_hosts file?

  • Does a Git repository exist on your remote server in the location you think it exists?

Using SparkleShare

Use SparkleShare exactly as you would DropBox or the NextCloud Desktop Client: drag-and-drop a file to add it, drag it to the Trash to delete it. All SparkleShare folders sync'd with any given project syncs automatically through the magickalfulness of Git hooks.

hpr2607 :: Processing

Released on 2018-07-31 under a CC-BY-SA license.

Get Processing from Download, extract, and launch. On Linux, just click the processing file.

Processing requires that either OpenJDK or Java to be installed.

Processing requires a void setup() function, which is a function that Processing expects whenever an application is launched. If you don't have a setup function, your application still launches, but with basic Processing defaults. Try this to start with:

void setup() {

Click the Run button in the top left corner to launch your [very simple] application: an empty window that is 480 pixels wide and 720 pixels tall.

Draw a rectangle on your canvas by invoking Processing's void draw() function:

void draw() {

Click the Run button in the top left corner to launch your application.

Add some colour to your rectangle:

void draw() {

Click the Run button in the top left corner to launch your application.

Make a simple painting app:

void setup() {

void draw() {
    if (mousePressed) {
    } else {

More Processing tricks: you can export your application as a standalone Java app, or as an Android .apk as long as you have the Android SDK installed.

Processing's documentation is excellent. It has examples for all functions, with pictures.

hpr2582 :: 3 Contribution case studies

Released on 2018-06-26 under a CC-BY-SA license.

How easy is it for your potential contributors to contribute? Klaatu looks at three open source and open culture projects to determine how easy they make it for your potential contributors to contribute?

hpr2577 :: Emigration

Released on 2018-06-19 under a CC-BY-SA license.

Confused about leaving your homeland for <strike>greener</strike> pastures? Maybe this episode will shed some light on the subject.

Public domain music from Can you find your national anthem? Do you know all the words to your national anthem? Either way, you should be ashamed of yourself.

hpr2574 :: Personal cash-only finance

Released on 2018-06-14 under a CC-BY-SA license.

Klaatu discusses the advantages and disadvantages of going [mostly] cash-only

hpr2573 :: Foundations of git rebase

Released on 2018-06-13 under a CC-BY-SA license.

A git rebase is like a git merge done through rose-coloured glasses.

You can see it for yourself by doing this little experiment. Assuming the alice directory is a valid git repository:

$ cd alice
$ echo "foo" >> rebase.episode
$ git add rebase.episode ; git commit -m 'begin rebase episode'
$ git checkout -b monsters

$ git branch
* monsters
$ echo "ghoul" >> ghoul.txt
$ git add ghoul.txt ; git commit -m 'ghoul'
$ git checkout master
$ echo "rogue" >> rogue.txt
$ git add rogue.txt ; git commit -m 'rogue'

$ git checkout monsters
$ echo "dragon" >> dragon.txt
$ git add dragon.txt ; git commit -m 'dragon'

$ git checkout master
$ echo "paladin" >> paladin.txt
$ git add paladin.txt ; git commit -m 'paladin'

You have now emulated a bunch of activity on two separate branches of a git repository. Create a copy of the repo so that you can perform two separate git actions.

$ cd ..
$ cp -r alice alice-merge
$ cp -r alice alice-base

Do an honest merge:

$ cd alice-merge
$ git checkout master
$ git merge monsters

The log shows you an accurate representation what got merged, and how all those changes came to be:

$ git log --oneline
123456 Merged monsters into master
789101 paladin
112131 dragon
415161 rogue
718191 ghoul
7ef217 begin rebase episode

Now perform a rebase.

$ cd ../alice-base
$ git checkout master
$ git rebase monsters

The log displays a different story than what really happened.

123456 Merged monsters into master
8e9122 paladin
21d163 rogue
912a3f dragon
51c098 ghoul
7ef217 begin rebase episode

Better? Worse? YOU DECIDE!

hpr2571 :: Kill Dr. Lucky

Released on 2018-06-11 under a CC-BY-SA license.

Details about Kill Doctor Lucky on

hpr2569 :: Pandemic: Reign of Cthulu board game review

Released on 2018-06-07 under a CC-BY-SA license.

Pandemic Reign of Cthulu

Pandemic original edition

Mods can be found online. For instance:

hpr2568 :: Personal finance

Released on 2018-06-06 under a CC-BY-SA license.

Personal finances


People need to save for retirement. But how do we do that?

Conventional wisdom in the USA says that Social Security is your retirement fund.

There's no guarantee that will still be around when you retire, and it's entirely out of your hands. It maybe a good bonus, but possibly it isn't something to rely on.

So how do we do it?

They don't teach you this stuff in school

People say you should save for retirement, but they forget to say how.

Currently, there are two de facto methods of funding retirement in the USA:

  • social security: abstract, not guaranteed. Assumes you start contributing to ssn early
  • 401k. abstract, indirect unless you take active role in tracking it. best if you start early.

In other countries, there may be significant alternatives. For instance, Kiwisaver in New Zealand.

These methods are OK, but difficult for you to interact with directly.

There are two direct levels of investment:

  1. At your bank: CDs and mutual funds
  • Go to your bank, ask to invest in a mutual fund or Certificate of Deposit (CD)
  1. Stock market: your local market and the US market
  • what: direct investment in "publically traded" (whatever that means) companies
  • how: or
  • In other countries, look for brokers who will invest your money in local or international markets

hpr2564 :: Intro to Fossil

Released on 2018-05-31 under a CC-BY-SA license.

Some shownotes for fossil

Create a new fossil repository:

  $ fossil new shownotes

Add your work to the repository:

  $ fossil add shownotes.html

Commit your work:

  $ fossil commit --comment "added shownote HTML file"

As a fun exercise, destroy your work.

  $ echo "klaatu said this was perfectly safe" > shownotes.html
  $ cat shownotes.html
  klaatu said this was perfectly safe

And now revert it back to the last known good version:

  $ fossil revert shownotes.html
  REVERT shownotes.html
  $ head -n1 shownotes.html
  <p>Some shownotes for fossil<p>

Did you accidentally revert? You can undo that.

  $ fossil undo shownotes.html

And then revert again.

  $ fossil revert shownotes.html
  REVERT shownotes.html
  $ head -n1 shownotes.html
  <p>Some shownotes for fossil<p>

Check your remote:

  $ fossil remote-url

Close a fossil repo:

  $ fossil close

See the fancy browser-based UI of your repo:

  $ fossil ui

hpr2556 :: Building trust

Released on 2018-05-21 under a CC-BY-SA license.

What is trust? How do you get it? How can you exploit it? How can you keep from being exploited?

hpr2553 :: Get ahead with git HEAD

Released on 2018-05-16 under a CC-BY-SA license.

This episode is light on actual commands, and mostly a narrative analysis of what git HEAD is and why it matters to you.

Some commands you can try:

$ cat ~/path/to/git/repo/.git/HEAD


$ ls ~/path/to/git/repo/.git/refs
$ cat ~/path/to/git/repo/.git/refs/master

hpr2550 :: Howto get started playing RPGs

Released on 2018-05-11 under a CC-BY-SA license.

Have you ever wanted to start playing a tabletop RPG, but weren't sure where to start? In this one-hour episode, Lostnbronx and Klaatu introduce you to role-playing games, including what you need to have in order to get started, how to build a character, what a game session is like, and how to find other people to play with.

Some resources mentioned in this episode:

  • The easy way in: Dungeons & Dragons 5th Edition Player's Handbook

  • A collection of free RPG systems Brent P. Newhall's Musæum of Fantastic Wonders

  • The OpenD6 system is a free and open and very flexible game using only standard 6-sided die

  • is a good, albeit dated, introduction to RPG modules and gameplay in general. It won't exactly fit anything you play, but reading it through might clarify how a typical game works (and actually it's pretty easy to adapt into a modern game like Pathfinder or D&D, if you want.).

  • Klaatu has a weekly podcast called Chronicles & Commons, wherein he talks about fantasy [Creative Commons and public domain] folklore in the context of RPG gaming (which in turn is discussed in context of storytelling).

hpr2516 :: Intro to git branch

Released on 2018-03-26 under a CC-BY-SA license.

These are all the commands covered in this episode. This is not a sequence, it's just all the commands in the episode, listed one after another.

Get changes from the remote repo:

$ git fetch

See all branches:

$ git branch --all

View a remote branch after you have fetched it:

$ git checkout origin/dev

Create a copy of a fetched remote branch in your local repo:

$ git checkout dev

Merge changes from remote origin/master into your local master branch:

$ git merge master origin/master

Fetch and merge automatically:

$ git pull

Create a new branch, and change to it:

$ git checkout -b dev

Merge dev into master:

$ git checkout master
$ git merge master dev

Merge master into dev

$ git checkout dev
$ git merge dev master

Delete the dev branch:

$ git branch -d dev

hpr2512 :: Intro to git remote

Released on 2018-03-20 under a CC-BY-SA license.

Instantiate a git repo:

$ mkdir alice
$ cd !$
$ git init

Add a remote:

$ git remote add origin URI_OF_REMOTE

Change a remote:

$ git remote set-url origin NEW_URI

A remote can be a server, it can be a local directory, an NFS share, pretty much whatever you want.

It is a Git convention that the primary remote is called origin. You don't have to call it that, but it's pretty common.

hpr2504 :: Intro to Git with pen and paper

Released on 2018-03-08 under a CC-BY-SA license.
git add

git commit -m "some useful message"

git push origin HEAD

hpr2461 :: Gitolite

Released on 2018-01-08 under a CC-BY-SA license.

Gitolite provides an admin a centralised interface, in the form of a configuration file, to make managing users, user permissions, repos, and user and repo groups easy. It abstracts Git users from UNIX users by defining a user by public keys, and manages permissions down to the branch-level. And better yet, it is itself managed over Git.

Proper documentation is available on

hpr2455 :: Interface Zero RPG Part 5

Released on 2017-12-29 under a CC-BY-SA license.

An extra-long episode of the grand finale of the Interface Zero RPG play-through.

Spoilers: Chaiwei dies in combat and Syd runs off with Tina.

At the end of the show are all the credits containing sound effects and source materials. Here they are in text form.

Sound effects were taken from Thanks to the following artists:

  • interfacezero/muzak/70891__spukkin__trumpetmetal.wav

  • interfacezero/muzak/212926__simongray__mojo-cafe-nr-wagamama.flac

  • interfacezero/muzak/243629__lebcraftlp__heavy-rain.flac

  • interfacezero/muzak/382735__schots__gun-shot.flac

  • interfacezero/muzak/186104__marcel-farres__elevator.flac

  • interfacezero/muzak/187866__theomegapixel__metal-grind.flac

  • interfacezero/muzak/66713__sunnysidesound__desk-pound.wav

  • interfacezero/muzak/367222__bluedelta__thunder-rain-low-frequencies-4-channel-48khz.wav

  • interfacezero/muzak/212678__fridobeck__firework-explosion-1.wav

  • interfacezero/muzak/213610__dpoggioli__laser-gun-explosion.wav

  • interfacezero/muzak/100772__cgeffex__huge-rocket-launcher.wav

  • interfacezero/muzak/336735__newagesoup__double-explosion-bright-dark.wav

  • interfacezero/ep2/329877__klavo1985__music-of-the-black-circus-the-very-best-by-kris-klavenes.flac

  • interfacezero/ep2/94914__pcaeldries__lakeside2.flac

  • interfacezero/ep2/153376__inchadney__the-bay.flac

  • interfacezero/ep3/152396__taavi55__big-smash.ogg

  • interfacezero/ep3/135465__joelaudio__quick-smash-001.wav

  • interfacezero/ep3/387177__pfranzen__smashing-a-glass.ogg


  • Lyphrygerator and Wood/Water by William Kenlon, used with permission.

  • All other music by Klaatu.


Want to play this game yourself?

Editor's note 2017-12-28: link added from comments.

hpr2451 :: Server Basics 105 OpenVPN Client

Released on 2017-12-25 under a CC-BY-SA license.

In the previous episode of this series, you set up an OpenVPN server. In this episode, Klaatu walks you through:

  1. Installing OpenVPN on a client machine.

  2. Generating a key and certificate request.

  3. Signing a client cert from the server.

  4. Configuring the client.conf file.

  5. Configuring the client routing table to use the VPN subnet.

  6. Pinging the server over VPN!!!

Where to go from here?

Your next steps should be to investigate how your org wants to use VPN, how your clients actually want to join the VPN (Network Manager has some nice features that makes joining a VPN fairly transparent). Have fun!

hpr2447 :: Server Basics 104 OpenVPN Server

Released on 2017-12-19 under a CC-BY-SA license.

In this episode, Klaatu demonstrates how to:

  1. Install OpenVPN

  2. Generate certificates for your OpenVPN server

  3. Generate a private key for your OpenVPN server

  4. Configure the /etc/openvpn/server.conf file

  5. Start the OpenVPN daemon

In case it is not clear, you can follow along with Klaatu, using the exact same options and configuration values as he is using for a successful install. You do not need to change

In the next episode, he will demonstrate how to do all of the above for OpenVPN clients.

VPN is a big topic that warrants a whole miniseries unto itself, so this and the next episode concentrate on getting a VPN up and running, with clients connected and pinging back to the server on a dedicated subnet. Additional config options based on your specific use-case are left for you to explore on your own.

hpr2446 :: Git server and git hooks

Released on 2017-12-18 under a CC-BY-SA license.

A sample post-receive git hook:


foreach arg ( $< )
  set argv = ( $arg )
  set refname = $1

set branch = `git rev-parse --symbolic --abbrev-ref $refname`
echo $branch

    if ( "$branch" == "master" ) then
      echo "Branch detected: master"
      echo "Do some stuff here."
    else if ( "$branch" == "dev" ) then
      echo "Branch detected: dev"
      echo "Do something else here."
        echo "Do something entirely different here."

hpr2444 :: Interface Zero Play-through Part 4

Released on 2017-12-14 under a CC-BY-SA license.

The investigation continues!

Guest voice in this and episode 3 by Gort.

hpr2441 :: Server Basics 103

Released on 2017-12-11 under a CC-BY-SA license.

Klaatu walks you through installing, configuring, and running fail2ban, and discusses the basics about firewalls.

hpr2437 :: Interface Zero Play-through Part 3

Released on 2017-12-05 under a CC-BY-SA license.

Klaatu, Lobath, and Thaj continue their play-through of the Interface Zero RPG, using the Job InSecurity adventure.

Lyphrygerator composed by William Kenlon, used with permission.

All other music by Klaatu.

Some sounds from used for texture. Obligatory credits will appear in final episode.

hpr2435 :: Server Basics 102

Released on 2017-12-01 under a CC-BY-SA license.

Klaatu talks about SSH, changing SSH ports, and using SSH keys for the server you presumably set up after hearing Server Basics 101 in this series.

hpr2429 :: Interface Zero RPG Play

Released on 2017-11-23 under a CC-BY-SA license.

The second session of Interface Zero RPG live play with Klaatu, Lobath, and Thaj.

This week, Chiawei and Syd reach Peter's apartment and do some quick detective work, and a little bit of minor bone-breaking.

If you're really keen to play, send Klaatu an email (Klaatu at the domain of this podcast, or The recording schedule is inflexible, Klaatu has oddly high standards for audio that he is inevitably compresses down to 64kbps, and the game has already started, but a new character or guest character is not out of the question!

No give-away this week, but we'll be giving a (digital) Pathfinder starter kit out next week.

hpr2428 :: git Blobs

Released on 2017-11-22 under a CC-BY-SA license.

How do you manage large binary blobs, like pictures or video or sounds, when using git?

In this episode, Klaatu explains two popular options:

Thanks to CapsLok at for the sound effect.

hpr2427 :: Server Basics 101

Released on 2017-11-21 under a CC-BY-SA license.

Klaatu covers the very very basics of servers: what they are, how to know one when you see one, what one ought to run, and why we have them.

hpr2425 :: Intro to XSL

Released on 2017-11-17 under a CC-BY-SA license.

Sure, you can use pandoc to process your Docbook XML, but why not learn a little XSL this weekend?


You must have xsltproc installed. It's available from your software repository.

Here is some sample XML for you:

<xml version="1.0">
    My name is <author>Foo</author>.

    You're listening to <emphasis role="bold">Hacker Public

And here's the complete XSL as demonstrated:

<xsl:stylesheet xmlns:xsl="" version="1.0">

  <xsl:template match="para">

  <xsl:template match="emphasis">

  <xsl:template match="emphasis[@role='bold']">

  <xsl:template match="author" name="host">

      <xsl:when test="$host = 'Klaatu'">

      <xsl:when test="$host = 'Gort'">


hpr2424 :: Interface Zero RPG Play

Released on 2017-11-16 under a CC-BY-SA license.

Klaatu, Lobath, and Thaj play a session of Interface Zero, a role playing game using the Pathfinder rules.

If you're new to RPG and want to hear how it's done, or you're just bored and want to hear some nerds play through a cyberpunk adventure, this is for you! Also - for one lucky listener - we have an RPG starter kit. Listen for details.

hpr2422 :: Kickstarter Post Mortem

Released on 2017-11-14 under a CC-BY-SA license.

Klaatu tried to fund art for a card game on Kickstarter. Missed the goal by 85%

This is a post mortem of how the Kickstarter went and where he may have gone wrong. Possibly you can learn from his mistakes. Possibly he has misdiagnosed his mistakes, and you are being misled. Choose wisely.

hpr2402 :: Petition: the card game for fanatics

Released on 2017-10-17 under a CC-BY-SA license.

Klaatu talks about a card game that he designed and is currently Kickstarting. Hear all about the exciting game play in this episode!

It's a neato fantasy battle game, and is Creative Commons and open source. He hopes to finance, specifically, the artwork, which is being done by artist Nikolai Mamashev on Linux with Krita.

If you want to contribute, go to

hpr2390 :: Still in the game

Released on 2017-09-29 under a CC-BY-SA license.

In a counterpoint to episode 2381, Klaatu talks about how PC gaming compares to tabletop gaming.

hpr2381 :: Benefits of a tabletop

Released on 2017-09-18 under a CC-BY-SA license.

Klaatu talks about the benefits of tabletop gaming over computer gaming.

hpr2378 :: Why Docbook?

Released on 2017-09-13 under a CC-BY-SA license.

What's so great about Docbook, any way? Glad you asked.

hpr2373 :: PCGen

Released on 2017-09-06 under a CC-BY-SA license.

Building characters for your next exciting tabletop RPG session? Use PCGen, and here's how!

hpr2372 :: Docbook

Released on 2017-09-05 under a CC-BY-SA license.

Forsake markdown now! Klaatu walks you through writing in Docbook, processing and rendering output.

hpr2361 :: Information Underground: Working Out

Released on 2017-08-21 under a CC-BY-SA license.
Deepgeek, Lostnbronx, and Klaatu talk about exercise.

hpr2313 :: NilFS2

Released on 2017-06-14 under a CC-BY-SA license.

Klaatu talks about NilFS2, including how to monitor checkpoints, create snapshots, and browse snapshots.

NILFS or NILFS2 (New Implementation of a Log-structured File System) is a log-structured file system implementation for the Linux kernel. It is being developed by Nippon Telegraph and Telephone Corporation (NTT) CyberSpace Laboratories and a community from all over the world. NILFS was released under the terms of the GNU General Public License (GPL).

hpr2282 :: Pathfinder Adventure Card Game

Released on 2017-05-02 under a CC-BY-SA license.

Klaatu introduces you to the Pathfinder and the Pathfinder Adventure Card Game.

And since it's in the same neighborhood, Klaatu also mentions the Open Game License and mentions more than once Forgotten Realms.

hpr2276 :: Tunnels and Trolls and Dungeon Delvers

Released on 2017-04-24 under a CC-BY-SA license.

Klaatu reviews the solo RPG experience provided by Tunnels & Trolls community.

Additionally, he mentions a nice Creative Commons rulebook (if you can call 2 pages a book) called Dungeon Delvers.

hpr2266 :: Gamebooks: Lone Wolf

Released on 2017-04-10 under a CC-BY-SA license.

Klaatu talks about the Lone Wolf series of solo RPG gamebooks from the 1980s.

hpr2178 :: Dice Mixer

Released on 2016-12-07 under a CC-BY-SA license.

Klaatu reviews the Dice Mixer.

Spoiler: it's really amazing and a heck of a lot of fun to put together.

Assembling the device Dice Mixer built

hpr2174 :: Dungeoneer Tabletop Game

Released on 2016-12-01 under a CC-BY-SA license.

Klaatu reviews the RPG card game, Dungeoneer, especially concentrating upon solitaire play.

If you're keen to play, you'll want to use Klaatu's re-write of the official rules, or his re-write and touch-up of the unofficial solo rules. Neither of these are unique in themselves, but Klaatu humbly believes that they're a lot easier to comprehend than those online or in the box.

hpr2168 :: Analogue Random Number Generation

Released on 2016-11-23 under a CC-BY-SA license.

Klaatu talks about different ways of coming up with random numbers without electronics.

Discussed: dice, flipping through a book, sequential modulo, shifting tables, and pocketdiceroller.

hpr2164 :: Skipbo Tabletop Game

Released on 2016-11-17 under a CC-BY-SA license.

Game design by Hazel "Skip" Bowman.

hpr2159 :: Coup Tabletop Game

Released on 2016-11-10 under a CC-BY-SA license.

hpr2152 :: Apples to Apples Tabletop Game

Released on 2016-11-01 under a CC-BY-SA license.

Klaatu reviews and ponders the game mechanics of Apples to Apples, and how they do and do not compare to Cards Against Humanity.

hpr2146 :: Cards Against Humanity Tabletop Game

Released on 2016-10-24 under a CC-BY-SA license.

Klaatu reviews the tabletop game, Cards Against Humanity. This is a non-offensive episode, so you can listen to it regardless of your feelings about the game.

hpr2141 :: Make Web Python with Flask

Released on 2016-10-17 under a CC-BY-SA license.

Klaatu talks about the Python web framework, Flask. Think Ruby-on-Rails but for Python, or a lightweight Django.

Links in this show:

hpr2136 :: Fluxx Tabletop Game

Released on 2016-10-10 under a CC-BY-SA license.

Klaatu reviews the card game series, Fluxx.

Fluxx is a card game, played with a specially designed deck published by Looney Labs. It is different from most other card games, in that the rules and the conditions for winning are altered throughout the game, via cards played by the players.

hpr2134 :: Shutdown Sequence Systemd

Released on 2016-10-06 under a CC-BY-SA license.

Set up a service to trigger FIRST (this would be the shutdown service):

# cat /lib/systemd/system/fakehalt.service

Description=Fake-Halt Service

ExecStart=/usr/local/bin/ #this will fail until fakevm succeeds

And then set up the one that you want to run and complete BEFORE shutdown is permitted:

# cat /lib/systemd/system/fakevm.service
Description=Fake Service


Create a script to represent the VM shutdown (or any process that you cannot anticipate the duration of)

# cat /usr/local/bin/

sleep 21
if [ X"$test" = "X1" ]; then
    echo "vm has shut down" > /tmp/fake.test
    exit 0
    exit 1

And a script to pass for a shutdown signal:

# cat /usr/local/bin/

sleep 3
cat /tmp/vmfake.test > /tmp/haltfake.test

Start the service you want to happen AFTER the first one:

# systemctl start fakehalt

What "should" happen is that fakehalt will fail to find a file called /tmp/fake.test to cat from, and so everything should go horribly wrong.

What actually happens is that systemd places fakehalt service on hold until it gets an exit 0 signal from the fake service. So if you wait 21 seconds and cat /tmp/fakehalt.test, you see that the cat from a file that did not exist when fakehalt was started - actually succeeded.

hpr2132 :: Gloom Tabletop Game

Released on 2016-10-04 under a CC-BY-SA license.

Klaatu reviews the card game “Gloom”, including its strengths, weaknesses, and potential for player mods.

hpr2130 :: Git push to two repositories at once

Released on 2016-09-30 under a CC-BY-SA license.
  1. Set up your git remotes (‘origin’ and ‘foo’)

  2. Create a new remote (‘all’) entry to encompass the existing targets

  3. Adjust ssh config as needed

  4. git push all HEAD

hpr2127 :: Tabletop Gaming

Released on 2016-09-27 under a CC-BY-SA license.

Klaatu ponders analogue programming and tabletop gaming.

hpr2121 :: Dark Cults Tabletop Game

Released on 2016-09-19 under a CC-BY-SA license.

Klaatu talks about the long-gone (but not forgotten, clearly) DARK CULTS tabletop game. His print-and-play revival is available here:

hpr2013 :: Parsing XML in Python with Xmltodict

Released on 2016-04-20 under a CC-BY-SA license.

If Untangle is too simple for your XML parsing needs, check out xmltodict. Like untangle, xmltodict is simpler than the usual suspects (lxml, beautiful soup), but it's got some advanced features as well.

If you're reading this article, I assume you've read at least the introduction to my article about Untangle, and you should probably also read, at some point, my article on using JSON just so you know your options.

Quick re-cap about XML:

XML is a way of storing data in a hierarchical arrangement so that the data can be parsed later. It's explicit and strictly structured, so one of its benefits is that it paints a fairly verbose definition of data. Here's an example of some simple XML:

<?xml version="1.0"?>
   <chapter id="prologue">
     The Beginning
     This is the first paragraph.

    <chapter id="end">
     The Ending
     Last para of last chapter.

And here's some info about the xmltodict library that makes parsing that a lot easier than the built-in Python tools:


Install xmltodict manually, or from your repository, or using pip:

$ pip install xmltodict

or if you need to install it locally:

$ pip install --user xmltodict


With xmltodict, each element in an XML document gets converted into a dictionary (specifically an OrderedDictionary), which you then treat basically the same as you would JSON (or any Python OrderedDict).

First, ingest the XML document. Assuming it's called sample.xml and is located in the current directory:

>>> import xmltodict
>>> with open('sample.xml') as f:
...     data = xmltodict.parse(

If you're a visual thinker, you might want or need to see the data. You can look at it just by dumping data:

>>> data
OrderedDict([('book', OrderedDict([('chapter',
[OrderedDict([('@id', 'prologue'),
('title', 'The Beginning'),
...and so on...

Not terribly pretty to look at. Slightly less ugly is your data set piped through json.dumps:

>>> import json
>>> json.dumps(data)
'{"book": {"chapter": [{"@id": "prologue",
"title": "The Beginning", "para": "This is the first paragraph."},
{"@id": "end", "title": "The Ending",
"para": "This is the last paragraph of the last chapter."}]

You can try other feats of pretty printing, if they help:

>>> pp = pprint.PrettyPrinter(indent=4)
>>> pp.pprint(data)
{ 'book': { 'chapter': [{'@id': 'prologue',
                         'title': 'The Beginning',
             'para': 'This is the ...
                         ...and so on...                 

More often than not, though, you're going to be "walking" the XML tree, looking for specific points of interest. This is fairly easy to do, as long as you remember that syntactically you're dealing with a Python dict, while structurally, inheritance matters.

Elements (Tags)

Exploring the data element-by-element is very easy. Calling your data set by its root element (in our current example, that would be data['book']) would return the entire data set under the book tag. We'll skip that and drill down to the chapter level:

>>> data['book']['chapter']
[OrderedDict([('@id', 'prologue'), ('title', 'The Beginning'),
('para', 'This is the first paragraph.')]),
OrderedDict([('@id', 'end'), ('title', 'The Ending'),
('para', 'Last paragraph of last chapter.')])]

Admittedly, it's still a lot of data to look at, but you can see the structure.

Since we have two chapters, we can enumerate which chapter to select, if we want. To see the zeroeth chapter:

>>> data['book']['chapter'][0]
OrderedDict([('@id', 'prologue'),
('title', 'The Beginning'),
('para', 'This is the first paragraph.')])

Or the first chapter:

>>> data['book']['chapter'][1]
OrderedDict([('@id', 'end'), ('title', 'The Ending'),
('para', 'Last paragraph of last chapter.')])

And of course, you can continue narrowing your focus:

>>> data["book"]["chapter"][0]['para']
'This is the first paragraph.'

It's sort of like Xpath for toddlers. Having had to work with Xpath, I'm happy to have this option.


You may have already noticed that in the dict containing our data, there is some special notation happening. For instance, there is no @id element in our XML, and yet that appears in the dict.

Xmltodict uses the @ symbol to signify an attribute of an element. So to look at the attribute of an element:

>>> data['book']['chapter'][0]['@id']

If you need to see each attribute of each chapter tag, just iterate over the dict. A simple example:

>>> for c in range(0,2):
...     data['book']['chapter'][c]['@id']


In addition to special notation for attributes, xmltodict uses the # prefix to denote contents of complex elements. To show this example, I'll make a minor modification to sample.xml:

<?xml version="1.0"?>
   <chapter id="prologue">
     The Beginning
      <para class="linux">
     This is the first paragraph.

    <chapter id="end">
     The Ending
      <para class="linux">
     Last para of last chapter.

Notice that the <para> elements now have a linux attribute, and also contain text content (unlike <chapter> elements, which have attributes but only contain other elements).

Look at this data structure:

>>> import xmltodict
>>> with open('sample.xml') as g:
...     data = xmltodict.parse(
>>> data['book']['chapter'][0]
OrderedDict([('@id', 'prologue'),
('title', 'The Beginning'),
('para', OrderedDict([('@class', 'linux'),
('#text', 'This is the first paragraph.')]))])

There is a new entry in the dictionary: #text. It contains the text content of the <para> tag and is accessible in the same way that an attribute is:

>>> data['book']['chapter'][0]['para']['#text']
'This is the first paragraph.'


The xmltodict module supports XML namespaces and can also dump your data back into XML. For more documentation on this, have a look at the module on

What to Use?

Between untangle, xmltodict, and JSON, you have pretty good set of options for data parsing. There really are diferent uses for each one, so there's not necessarily a "right" or "wrong" answer. Try them out, see what you prefer, and use what is best. If you don't know what's best, use what you're most comfortable with; you can always improve it later.


Made on Free Software.

hpr2012 :: Parsing XML in Python with Untangle

Released on 2016-04-19 under a CC-BY-SA license.

XML is a popular way of storing data in a hierarchical arrangement so that the data can be parsed later. For instance, here is a simple XML snippet:

<?xml version="1.0"?>
   <chapter id="prologue">
     The Beginning

The nice thing about XML is that it is explicit and strictly structured. The trade-off is that it's pretty verbose, and getting to where you want to go often requires fairly complex navigation.

If you do a quick search online for XML parsing in Python, your two most common results are lxml and beautifulsoup. These both work, but using them feels less like opening a dictionary (as with JSON) to look up a definition and more like wandering through a library to gather up all the dictionaries you can possibly find.

In JSON, the thought process might be something like:

"Go to the first chapter's title and print the contents."

With traditional XML tools, it's more like:

"Open the book element and gather all instances of titles that fall within those chapters. Then, look into the resulting object and print the contents of the first occurrence."

There are at least two libaries that you can install and use to bring some sanity to complex XML structures, one of which is untangle.


With untangle, each element in an XML document gets converted into a class, which you can then probe for information. Makes no sense? well, follow along and it will become clear:

First, ingest the XML document. Assuming it's called sample.xml and is located in the current directory:

>>> import untangled
>>> data = untangle.parse('sample.xml')

Now our simple XML sample is sitting in RAM, as a Python class. The first element is <book> and all it contains is more elements, so its results are not terribly exciting:

Element(name = book, attributes = {}, cdata = )

As you can see, it does identify itself as "book" (under the name listing) but otherwise, not much to look at. That's OK, we can keep drilling down:

Element(name = chapter, attributes = {'id': 'prologue'}, cdata = )

Now things get more interesting. The next element identifies itself as "chapter", and reveals that it has an attribute "id" which has a value of "prologue". To continue down this path:

Element(name = title, attributes = {}, cdata = The Beginning )

And now we have a pretty complete picture of our little XML document. We have a breadcrumb trail of where we are in the form of the class we are invoking ( and we have the contents of our current position.


That's very linear; if you know your XML schema (and you usually do, since XML is quite strict) then you can grab values without all the walking. For instance, we know that our chapters have 'id' attributes, so we can ask for exactly that:


You can also get the contents of elements by looking at the cdata component of the class. Depending on the formatting of your document, untangle may be a little too literal with how it stores contents of elements, so you may want to use .strip() to prettify it:

'The Beginning'

Dealing with More Than One Element

My example so far is nice and tidy, with only one chapter in the book. Generally you'll be dealing with more data than that. Let's add another chapter to our sample file, and some content to each:

<?xml version="1.0"?>
   <chapter id="prologue">
     The Beginning
     This is the first paragraph.

    <chapter id="end">
     The Ending
     Last para of last chapter.

Accessing each chapter is done with index designations, just like with a dict:

Element(name = chapter, attributes = {'id': 'prologue'}, cdata = )
Element(name = chapter, attributes = {'id': 'end'}, cdata = )

If there is more than one instance of a tag, you must use a designator or else untangle won't know what to return. For example, if we want to access either the title or para elements within a chapter:

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'list' object has no attribute 'title'

Oops. But if we tell it which one to look at:

'The Beginning'
'The Ending'

Or you can look at the paragraph instead of the title. The lineage is the same, only instead of looking at the title child, you look at the para child:

'This is the first paragraph.'
'Last para of last chapter.'

You can also iterate over items:

>>> COUNT = [0,1]
>>> for TICK in COUNT:
...     print([TICK])
Element <chapter> with attributes {'id': 'prologue'} and children
[Element(name = title, attributes = {}, cdata = The Beginning ),
Element(name = para, attributes = {}, cdata = This is the first paragraph.)]

Element <chapter> with attributes {'id': 'end'} and children
[Element(name = title, attributes = {}, cdata = The Ending ),
Element(name = para, attributes = {}, cdata = Last para of last chapter.)]

And so on.

Easy and Fast

I'll admit the data structure of the classes does look odd, and you could probably argue it's not the cleanest and most elegant of all output; it's unnerving to see empty cdata fields or to constantly run into the need to strip() whitespace. However, the ease and speed and intuitiveness of parsing XML with untangle is usually well worth any trade-offs.


Made on Free Software.

hpr2010 :: Parsing JSON with Python

Released on 2016-04-15 under a CC-BY-SA license.

JSON is a popular way of storing data in a key/value type arrangement so that the data can be parsed easily later. For instance, here is a very simple JSON snippet:


If you are like me, three questions probably spring to your mind:

  1. That looks an awful lot like a Python dictionary.

    Yes, it looks exactly like a Python dictionary. They are shockingly similar. If you are comfortable with Python lists and dictionaries, you will feel right at home with JSON.

  2. I don't feel comfortable with dictionaries, can't I just use a delimited text file?

    You can, but you will have to write parsers for it yourself. If your data gets very complex, the parsing can get pretty ugly.

    That is not to say that you should not use a simple delimited text file if that is all that your programme needs. For example, I would not want to open a config file as a user and find that I have to format all my options as valid JSON.

    Just know that JSON is out there and available, and that the JSON Python module has some little features that make your life easier when dealing with sets of data.

  3. Why not use XML instead?

    You can. Mostly one should use the most appropriate format for one's project. I'm a big fan of XML, but sometimes JSON makes more sense.

I am not going to make this post about teaching the JSON format. If you need clarification on how to structure data into JSON, go through a tutorial on it somewhere; there are several good ones online. Honestly, it's not that complex; you can think of JSON as nested dictionaries.

Starting from scratch, let's say that you write a programme that by nature gathers data as it runs. When the user quits, you want to save the data to a file so that when the user resumes the app later, they can load the file back in and pick up where they left off.

Storing Data as JSON

At its most basic, the JSON data structure is basically the same as a Python dictionary, and in fact the nice thing about JSON is that it can be directly imported into a Python dictionary. Usually, however, you are resorting to JSON because you have somewhat complex data, so in the sample code we will use a dictionary-within-a-dictionary:

#!/usr/bin/env python

game = {'tux': {'health': 23, 'level': 4}, 'beastie': {'health': 13, 'level': 6}}
# you can always add more to your dictionary

game['konqi'] = {'health': 18, 'level': 7}

That code creates a ditionary called game which stores the player name and a corresponding dictionary of attributes about how the player is doing in the progress of the game. As you can see after the comment, adding new players is simple.

Now let's see how to save that data to a save file.

## continued...
import json

with open('dosiero.json', 'w') as outfile:
    json.dump(game, outfile)

That would be your save command. Simple as that, all the structured content of your game dictionary is committed to a file on your hard drive.

Reading Data from a JSON File

If you are saving data to JSON, you probably will evenually want to read the data back into Python. For this, Python features the function json.load

import json

dosiero = open('dosiero.json')
game = json.load(dosiero)

print game['tux']     # prints {'health': 23, 'level': 4}
print game['tux']['health']    # prints 23
print game['tux']['level']     # prints 4

# when finished, close the file


As you can see, JSON integrates surprisingly well with Python, so it's a great format when your data fits in with its model.

Have fun!


Made with Free Software.

hpr1942 :: Kobo Touch N-905 E-Reader

Released on 2016-01-12 under a CC-BY-SA license.

Klaatu reviews the Kobo Touch N-905 e-reader.

Too Long; Didn't Listen: it's a positive review and the device mostly works well with Linux. There are some exceptions, such as the need to hack around the registration process; luckily, that's easy:

That being "the ugly", here are the Good and the Bad:


  • works with Linux, after one initial hack
  • uses file manager or calibre
  • great format support (EPUB, EPUB3, PDF, MOBI, JPEG, GIF, PNG, BMP, TIFF, TXT, HTML, RTF, CBZ, CBR)
  • e-ink
  • great battery life (lasts a month on one charge, with every evening and weekend filled with reading)
  • a little more interactive and configurable than expected
  • one device, one app, one purpose
  • small, lightweight, convenient
  • cheap ($60 USD)
  • expansion up to 32gb


  • requires registration (or a rego hack)
  • rearranges your books by meta data; no override to respect your dirs
  • touch screen
  • slow (though not annoyingly slow)
  • long time to index books
  • hard to keep track of books you are currently reading
  • sleep/off screen should be more configurable

hpr1937 :: Klaatu talks to Cloudera about Hadoop and Big Data

Released on 2016-01-05 under a CC-BY-SA license.

Cloudera delivers the modern platform for data management and analytics. We provide the world’s fastest, easiest, and most secure Apache Hadoop platform to help you solve your most challenging business problems with data.

hpr1932 :: Klaatu interviews Grafana

Released on 2015-12-29 under a CC-BY-SA license.

Grafana provides a powerful and elegant way to create, explore, and share dashboards and data with your team and the world.

Grafana is most commonly used for visualizing time series data for Internet infrastructure and application analytics but many use it in other domains including industrial sensors, home automation, weather, and process control.

hpr1927 :: Ansible Interview

Released on 2015-12-22 under a CC-BY-SA license.

Klaatu talks to Ansible at All Things Open conference.

hpr1923 :: Klaatu and System76

Released on 2015-12-16 under a CC-BY-SA license.

Klaatu interviews Sam about kjd newest line of System76 computers, now with an all metal body! (the computers, not Klaatu, or Sam)

hpr1917 ::

Released on 2015-12-08 under a CC-BY-SA license.

Klaatu interviews Rikki Endsley from, a community-driven website covering news and events in the open source world. Klaatu sometimes contributes to, so this interview is tainted and biased. Beware!

hpr1912 :: OpenNMS at All Things Open Conference

Released on 2015-12-01 under a CC-BY-SA license.

Klaatu talks to Jessie the OpenNMS project at the All Things Open Conference.

hpr1907 :: Charlie Reisinger and Penn Manor

Released on 2015-11-24 under a CC-BY-SA license.

Klaatu interviews Charlie Reisinger about how Penn Manor school district uses of open source...on every student's laptop.

hpr1880 :: Arduino Bluetooth HOWTO

Released on 2015-10-16 under a CC-BY-SA license.

Klaatu talks about the HC-05 and -06 series of bluetooth modules and how to use them with an Arduino, including some basic code on the Arduino to get it to respond to signals over bluetooth, and some basic PyQt code on how to send signals to the bluetooth device. PLUS, he talks about configuring the bluetooth so that it is connected to the serial port of your system (so that Python can use it).

A super basic bluetooth controller app can be found here: (it's Klaatu's code, and it's not quite finished, so if you have improvements or questions, feel free to comment or merge or email)

hpr1856 :: ssh config

Released on 2015-09-14 under a CC-BY-SA license.

Put a file called 'config' into ~/.ssh and you can define any option you would normally provide as part of the command as an automatically-detected configuration.

For example:

host foo
    identityfile /home/klaatu/.ssh/foo_rsa
    port 2740
    protocol 2

Makes the command 'ssh klaatu@foo' look like this to SSH:

ssh -p2740 -i ~/.ssh/foo_rsa

hpr1691 :: Arduino 101 Arduino IO

Released on 2015-01-26 under a CC-BY-SA license.

In this two-part series, Klaatu introduces you to the Arduino. First, learn about the breadboard and how to make electricity course through it in order to power your very own simple circuit.

To follow along with what Klaatu is talking about, refer to these two graphics:

And here are diagrams of the simple circuits that Klaatu constructs.

image: a diagramme of the simple circuit in todays show

The simple code to reset the servo:

#include <Servo.h>
Servo myservo;

int servoPosition;

void setup()

void loop() {}

And the code that responds to input:

#include <Servo.h>
Servo myservo; 

int servoPosition;
int servoMax = 180;
int servoMin = 0;

int value;
int valMax = 600;
int valMin = 50;

void setup()

void loop() 
  value = analogRead(0);
  servoPosition = map(value, valMin, valMax, servoMax, servoMin);
  servoPosition = constrain(servoPosition, servoMin, servoMax);

And here is a bonus diagramme that you can try to create, using a light sensor, servo, and resistor.

image: homework

hpr1690 :: Arduino 101 Breadboard

Released on 2015-01-23 under a CC-BY-SA license.

In this two-part series, Klaatu introduces you to the Arduino. First, learn about the breadboard and how to make electricity course through it in order to power your very own simple circuit.

To follow along with what Klaatu is talking about, refer to these two graphics:

And here are diagrams of the simple circuits that Klaatu constructs.

image: a diagram of the simplest circuit in todays show

image: a diagram of the switched circuit in todays show

hpr1668 :: Nixstaller

Released on 2014-12-24 under a CC-BY-SA license.

Cross-distro and -POSIX packages are easy with Nixstaller. (Note that this pre-dates and is entirely unrelated to NixOS or Nix packages.)

Download Nixstaller from and read the docs there.

Review the sample package templates included in the examples dir.

Generate an empty template dir with

Modify the config.lua and run.lua files to suit your needs.

Place your payload(s) into the appropriate folders.

Generate your re-distributable install file with

geninstall foo-1.0.0

That's it!

hpr1616 :: Howto Use Webfonts

Released on 2014-10-13 under a CC-BY-SA license.

Klaatu reveals the secret of webfonts WITHOUT using Google. How can this be? Listen and find out.

hpr1606 :: Howto VNC

Released on 2014-09-29 under a CC-BY-SA license.

Klaatu talks about how to get VNC up and running. It focuses on x11vnc but basically it applies to any variety.

Virtual Network Computing
From Wikipedia, the free encyclopedia

In computing, Virtual Network Computing (VNC) is a graphical desktop sharing system that uses the Remote Frame Buffer protocol (RFB) to remotely control another computer. It transmits the keyboard and mouse events from one computer to another, relaying the graphical screen updates back in the other direction, over a network.
VNC is platform-independent – There are clients and servers for many GUI-based operating systems and for Java. Multiple clients may connect to a VNC server at the same time. Popular uses for this technology include remote technical support and accessing files on one's work computer from one's home computer, or vice versa.
VNC was originally developed at the Olivetti & Oracle Research Lab in Cambridge, United Kingdom. The original VNC source code and many modern derivatives are open source under the GNU General Public License.
There are a number of variants of VNC which offer their own particular functionality; e.g., some optimised for Microsoft Windows, or offering file transfer (not part of VNC proper), etc. Many are compatible (without their added features) with VNC proper in the sense that a viewer of one flavour can connect with a server of another; others are based on VNC code but not compatible with standard VNC.
VNC and RFB are registered trademarks of RealVNC Ltd. in the U.S. and in other countries.

hpr1601 :: Howto Install LAMP

Released on 2014-09-22 under a CC-BY-SA license.

If you're just starting out as a web developer or designer, you should know about LAMP and how to use it. This episode introduces you to the basics.

LAMP (software bundle)
From Wikipedia, the free encyclopedia
LAMP is an acronym for an archetypal model of web service solution stacks, originally consisting of largely interchangeable components: Linux, the Apache HTTP Server, the MySQL relational database management system, and the PHP programming language. As a solution stack, LAMP is suitable for building dynamic web sites and web applications.

hpr1596 :: About the Word "Hack"

Released on 2014-09-15 under a CC-BY-SA license.

Klaatu muses about the word "hack" and what it means, what it should mean, and how we can keep it meaningful.

hpr1579 :: Crowd Sourced Air Quality Monitoring

Released on 2014-08-21 under a CC-BY-SA license.

Klaatu interviews a programmer about new crowd-sourced air quality detection systems. Big crowds at this Carnegie Melon event, so the sound quality is not great.



hpr1574 :: Arts and Bots

Released on 2014-08-14 under a CC-BY-SA license.

Klaatu interviews a teacher about the use of robots and programming in liberal arts classes. Big crowds at this Carnegie Melon event, so the sound quality is not great.



hpr1522 :: How to Use Docker and Linux Containers

Released on 2014-06-03 under a CC-BY-SA license.

How to use Docker and Linux Containers

hpr1494 :: The Next Gen is You (2/2)

Released on 2014-04-24 under a CC-BY-SA license.

Steam OS or Steam on Linux, anti-micro for game controller optimisation.
Part 2 of 2

hpr1493 :: The Next Gen is You (1/2)

Released on 2014-04-23 under a CC-BY-SA license.

Steam OS or Steam on Linux, anti-micro for game controller optimisation.

hpr1376 :: How Should We Then Teach the Art of Computing?

Released on 2013-11-11 under a CC-BY-SA license.
In this episode Klaatu discusses the Art of Computing.

hpr1358 :: How to set up GnuPG, a PGP-compliant encryption system

Released on 2013-10-16 under a CC-BY-SA license.

Klaatu explains how to set up GnuPG, a PGP-compliant encryption system, and use it with both Thunderbird and Mutt mail clients.


Set up GnuPG:

Using Mutt:

Klaatu's humble dot-muttrc file: (there are better ones out there)

Klaatu's public key

hpr1277 :: Icecast 102

Released on 2013-06-25 under a CC-BY-SA license.

Klaatu talks about how to feed Icecast with different sources like MPD and BUTT, and how to use the front-ends ncmpcpp and gmpc.

Here are the simple and ugly shell scripts that Klaatu uses to manage his Icecast streaming station. They aren't quite finished products yet but they'll give you an idea of how one might realistically manage an internet radio station from the shell:

Klaatu is indebted to Delwin, The Last Known God, and Ruji for their help on this episode.

hpr1272 :: Open Badges?

Released on 2013-06-18 under a CC-BY-SA license.

Cyanide Cupcake and Klaatu ponder the new Open Badge spec, and whether badges are important, useful, or...a government conspiracy!


hpr1259 :: Cyanide Cupcake and Klaatu

Released on 2013-05-30 under a CC-BY-SA license.

Cyanide Cupcake talks to Klaatu about the Scratch programming language.


hpr1207 :: Icecast 101

Released on 2013-03-19 under a CC-BY-SA license.

Klaatu talks about how to set up Icecast, new Ices, old Ices, and a nice little (simple) HTML5 player. This is part one of a two-part series.

Here are the raw commands for Icecast, Ices, and Ices-cc:

#start the streaming server
icecast -c /etc/icecast.xml -B

#start the mp3 stream
ices-cc -c /etc/ices-cc.conf -F /home/dj/playlist.txt -R -b 96 -m mp3 -P radio

# start the ogg stream
ices /etc/ices/ices-playlist.xml

Here is the code for the simple HTML5 player that Klaatu mentions in the episode. It's straight HTML5 but in case you're new to HTML5 then this could be useful:

<!DOCTYPE html>
<html lang="en">
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <title>My Great Streaming Server Example dot Com</title>
<div id="player">
<audio width="100px" height="200px" autoplay loop controls autobuffer preload="auto">
      <source src="" type="audio/mp3" />
      <source src="" type="audio/ogg" />

Klaatu is indebted to Kwisher, Delwin, and Ruji for their help on this series.

hpr1188 :: Rmail in Emacs

Released on 2013-02-20 under a CC-BY-SA license.

11 hours to go. 235 funders Contributed $8,633 USD of $20,000 43%
Donate here

Klaatu sneaks in an addendum to his Emacs mini-series on howto use Rmail in Emacs. Bonus topics include how to configure fancy Unix mail tools like msmtp, procmail, tmail, and fetchmail.

hpr1127 :: AFP file share on a Linux server

Released on 2012-11-27 under a CC-BY-SA license.

Klaatu continues his Networking Basics series with a howto set up a netatalk/AFP file share on a Linux server for native-like file sharing for Mac clients.

Apple Filing Protocol
From Wikipedia, the free encyclopedia

This article includes a list of references, but its sources remain unclear because it has insufficient inline citations. Please help to improve this article by introducing more precise citations. (March 2008) The Apple Filing Protocol (AFP), formerly AppleTalk Filing Protocol, is a proprietary network protocol that offers file services for Mac OS X and original Mac OS. In Mac OS X, AFP is one of several file services supported including Server Message Block (SMB), Network File System (NFS), File Transfer Protocol (FTP), and WebDAV. AFP currently supports Unicode file names, POSIX and access control list permissions, resource forks, named extended attributes, and advanced file locking. In Mac OS 9 and earlier, AFP was the primary protocol for file services.

hpr1121 :: Klaatu continues his Networking Basics series with a SAMBA howto.

Released on 2012-11-19 under a CC-BY-SA license.
Klaatu continues his Networking Basics series with a SAMBA howto.

hpr0882 :: RPM format

Released on 2011-12-19 under a CC-BY-SA license.

Klaatu continues his three-part series on packaging applications for GNU Linux and BSD. In this second episode, he covers the RPM format and howto use rpmbuild to create both binary and source RPM packages. He uses SigFLUP's yesplz as an example again, so be sure to grab the source if you'll be following along.

Get this episode in ogg vorbis courtesy the GNU World Order.

hpr0876 :: Packaging applications: BSD ports

Released on 2011-12-09 under a CC-BY-SA license.

Klaatu concludes his three-part series on packaging applications for GNU Linux and BSD. In this episode, he covers BSD ports; how to get them, how to write one, and how to install it. Then he gives his opinion on the myriad packaging options that unix users have available to them.

Get this episode in ogg vorbis courtesy the GNU World Order.

hpr0872 :: Packaging YUM

Released on 2011-12-05 under a CC-BY-SA license.

A bonus episode in the Packaging Applications for Linux mini series! Inspired by Thrice in IRC, Klaatu discusses the yum package manager and how to weild it like an ancient RPM warrior.

hpr0866 :: Publican, the user-friendly Perl frontend to Docbook XML

Released on 2011-11-28 under a CC-BY-SA license.

Klaatu introduces you to Publican, the user-friendly Perl frontend to Docbook XML from the Fedora Linux Project. Also, how to set up vim with XML tag completion.


Also see Docbook The Definitive Guide

nXML-mode for GNU Emacs.

Feel free to glance over the dot-emacs file that Klaatu uses, mostly stolen from Unix guru Bill Von Hagen (who in turn stole it from lots of other people; read comments for credits)

XML Completion for Vim

hpr0861 :: Emacs Part 3: The Reckoning.

Released on 2011-11-20 under a CC-BY-SA license.

A small mini series (three parts) on GNU Emacs; Klaatu tells you how to use it, when to use it and when not to, why you'd want to use it, and most of all - how to become a pro on it! Not a sales pitch for Emacs, just a harmless introduction. First try is free.

hpr0856 :: GNU Emacs 2

Released on 2011-11-11 under a CC-BY-SA license.

Second episode of three in Klaatu's GNU Emacs mini series. This time, you and Klaatu will tackle the .emacs file and learn how to bring text highlighting, modern-style copy/paste keybindings, and even a little taste of buffers and frame-type things.

hpr0853 :: Pat Volkerding of Slackware Linux chats with Klaatu

Released on 2011-11-08 under a CC-BY-SA license.

Pat Volkerding of Slackware Linux chats with Klaatu and whomever happens to wander by (Maco, Vincent Batts, Chad Wallenberg, and others) at the SELF afterparty.


From Wikipedia, the free encyclopedia

Slackware is a free and open source Linux-based operating system. It was one of the earliest operating systems to be built on top of the Linux kernel and is the oldest currently being maintained. Slackware was created by Patrick Volkerding of Slackware Linux, Inc. in 1993. The current stable version is 13.37, released on April 27, 2011.
Slackware aims for design stability and simplicity, and to be the most "Unix-like" Linux distribution, making as few modifications as possible to software packages from upstream and using plain text files and a small set of shell scripts for configuration and administration.

photo of Pat Volkerding

Warning: this is not a proper interview, just 40 minutes of aimless and fairly noisy chit chat at a party. So it's probably not for everyone, although if you're a Slackware fan then it might be of some interest.

hpr0852 :: GNU Emacs 1

Released on 2011-11-07 under a CC-BY-SA license.

A small mini series (three parts) on GNU Emacs; Klaatu tells you how to use it, when to use it and when not to, why you'd want to use it, and most of all - how to become a pro on it! Not a sales pitch for Emacs, just a harmless introduction. First try is free.

emacs logo

GNU Emacs is an extensible, customizable text editor—and more. At its core is an interpreter for Emacs Lisp, a dialect of the Lisp programming language with extensions to support text editing. The features of GNU Emacs include:

  • Content-sensitive editing modes, including syntax coloring, for a variety of file types including plain text, source code, and HTML.
  • Complete built-in documentation, including a tutorial for new users.
  • Full Unicode support for nearly all human languages and their scripts.
  • Highly customizable, using Emacs Lisp code or a graphical interface.
  • A large number of extensions that add other functionality, including a project planner, mail and news reader, debugger interface, calendar, and more. Many of these extensions are distributed with GNU Emacs; others are available separately.

hpr0846 :: Jared Smith from Fedora

Released on 2011-10-30 under a CC-BY-SA license.

Klaatu, losing his voice from too much Ohio Linux Festivities, interviews Jared Smith, the project manager of Fedora Linux.

hpr0841 :: Jonathan Nadeau

Released on 2011-10-23 under a CC-BY-SA license.

At the Ohio Linux Fest, Klaatu interviews Jonathan Nadeau about the FSF, Trisquel Linux, Linux and accessibility, and how non-programmers can get involved with software projects.

hpr0836 :: Jeff from No Machine

Released on 2011-10-16 under a CC-BY-SA license.

Klaatu interviews Jeff from No Machine.

hpr0831 :: Chris from

Released on 2011-10-09 under a CC-BY-SA license.

Klaatu interviews Chris from, at the Ohio Linux Fest.

hpr0827 :: HPR booth and HostGator

Released on 2011-10-03 under a CC-BY-SA license.

Klaatu talks about howto establish an HPR booth at your favourite tech conference, and gives a report about HPR's presence at the Ohio Linux fest this year. Also, an interview with Lance from

hpr0823 :: Klaatu talks to Trevor, a programmer for Phonon's Gstreamer backend

Released on 2011-09-27 under a CC-BY-SA license.

At the Ohio Linux Fest, Klaatu talks to Trevor, a programmer for Phonon's Gstreamer backend.

hpr0820 :: Setting up a web server and a mySQL server

Released on 2011-09-22 under a CC-BY-SA license.

Klaatu continues his Networking Basics series with an overview on setting up and configuring a web server and a mySQL server.

Get the ogg vorbis version from the Gnu World Order.

hpr0807 :: MaraDNS

Released on 2011-09-05 under a CC-BY-SA license.

Klaatu continues his Networking Basics series with a howto set up a simple DNS server using MaraDNS.

Get the ogg vorbis version from the Gnu World Order.

hpr0801 :: Slackbuilds

Released on 2011-08-28 under a CC-BY-SA license.

Klaatu begins a three-part series on packaging applications for GNU Linux and BSD. In this first episode, he covers Slackbuilds using SigFLUP's yesplz as an example.

Get this episode in ogg vorbis courtesy the GNU World Order.

hpr0793 :: Server/Client relationship, DHCP server

Released on 2011-08-16 under a CC-BY-SA license.

Remember back in the 400s of HPR when Klaatu was doing a Networking Basics miniseries? Well, its back, with an introduction to the concept of the Server / Client relationship, how to set up a server as an internet gateway and a DHCP server.

hpr0780 :: NovaCut

Released on 2011-07-29 under a CC-BY-SA license.
klaatu talks to Jason DeRose about NovaCut (
The fund raiser will end on Friday Jul 29, 11:00pm EDT and they have 774 Backers. They already have raised $25,435 of their $25,000 goal

hpr0767 :: Maddog and "super dumb terminals"

Released on 2011-07-11 under a CC-BY-SA license.

At the South East Linux Fest 2011, Klaatu talks to Maddog about "super dumb terminals", super computing, a sys admin's rightful position in the world, and much more.

For lovers of ogg, the episode can also be found at the Gnu World Order website.

hpr0765 :: South East Linux Fest organizers

Released on 2011-07-07 under a CC-BY-SA license.

Klaatu talks to the organizers of this year's South East Linux Fest, Dave S. Yates (of the Lotta Linux Links podcast) and the tireless Mr. Jeremy Sands.

For lovers of ogg, the episode can also be found at the Gnu World Order website.

hpr0760 :: /dev/Rob0 of maintainer of the mailing list

Released on 2011-06-30 under a CC-BY-NC-SA license.

Klaatu talks to /dev/Rob0, a Slackware user, maintainer of the mailing list, and a presenter at the South East Linux Fest 2011.

For lovers of ogg, the episode can also be found at the Gnu World Order website.

hpr0731 :: Klaatu the ubiquity and potential danger of the rm command

Released on 2011-05-22 under a CC-BY-NC-SA license.

Klaatu discusses the imbalance between the ubiquity and potential danger of the rm command. He proposes the alternative command, trash.

Get this episode in ogg vorbis.

Git the trash shell script from

hpr0727 :: HOWTO root and mod an Andr0id phone.

Released on 2011-05-16 under a CC-BY-NC-SA license.

Klaatu's HOWTO root and mod an Andr0id phone.


This episode is also available in ogg vorbis.

hpr0723 :: How to be a safe computerist

Released on 2011-05-10 under a CC-BY-NC-SA license.

Klaatu brings his Urban Camping series to a close with a discussion of how to be a safe computerist whilst urban camping. He covers ssh, X Forwarding, tor, tcpdump, and general computer common sense.

The ogg version is available from GNU World Order.

hpr0720 :: CLI Magic

Released on 2011-05-06 under a CC-BY-NC-SA license.

Klaatu talks to Mark, aka deltaRay, from CLI Magic and about the command line, the Indiana Linux Fest, and more!

Git yer ogg version from the GNU World Order.

hpr0711 :: Klaatu and Verbal chat about web2py

Released on 2011-04-25 under a CC-BY-NC-SA license.

At the first Indiana Linux Fest, Klaatu and Verbal sit down to chat about web2py.

Free codec lover? Get your ogg here.

hpr0641 :: Urban Camping ep 7

Released on 2011-01-17 under a CC-BY-NC-SA license.

What does an urban camper do all day? Find out in this exciting seventh episode of the HOW TO be an Urban Camper mini series!

Say, is that Irving Gillette and the lovely Ada Jones singing "In the Heart of the City That Has No Heart" at the end? Why yes! it is. But don't thank me, thank

hpr0638 :: Urban Camping ep 6

Released on 2011-01-12 under a CC-BY-NC-SA license.

Episode 6 of HOW TO be an Urban Camper. This one talks about making money whilst urban camping.

End song is "Play or Give me my Money Back" by Michael Tokarick via

hpr0634 :: Urban Camping ep 5

Released on 2011-01-06 under a CC-BY-NC-SA license.

The fifth episode in Klaatu's HOW TO be an Urban Camper mini series, about where to find food.

hpr0626 :: Urban Camping ep 4

Released on 2010-12-27 under a CC-BY-NC-SA license.

The third episode in Klaatu's HOW TO be an Urban Camper mini series, about organization of your gear, and the eternal quest for the perfect coffee travel mug.

hpr0624 :: Urban Camping ep 3

Released on 2010-12-23 under a CC-BY-NC-SA license.

The third episode in Klaatu's HOW TO be an Urban Camper mini series, about the always engrossing topic of personal hygiene.

hpr0620 :: Klaatu holds an interview with Tek Systems

Released on 2010-12-17 under a CC-BY-NC-SA license.
Klaatu talks to Tek Systems at SELF 2010. Listen to the ogg vorbis version courtesy of the Bad Applez.

hpr0615 :: Urban Camping ep 2

Released on 2010-12-10 under a CC-BY-NC-SA license.

The second episode in the HOW TO be an Urban Camper mini series. This one covers finding shelter, things to look out for, scouting out the neighborhood, police and other thugs, and where not to stay..
End song excerpt by the Princess Orchestra, courtesy

hpr0607 :: Klaatu talks to Rebecca from

Released on 2010-11-30 under a CC-BY-NC-SA license.
Klaatu talks to Rebecca from about the Semantic Web, social networking, privacy and the internet, hipsters, and hipster boxing. Want to hear all of this in the free codec ogg vorbis? get it from the good folks over at the Gnu World order

hpr0602 :: Urban Camping ep 1

Released on 2010-11-23 under a CC-BY-NC-SA license.

Klaatu's first episode in his HOW TO be an Urban Camper mini series.

Trombone sample from catalogue number 73581
End song by Jimmy Rogers, courtesy

hpr0592 :: FOSScon: An interview with CrissiD and Charles

Released on 2010-11-09 under a CC-BY-NC-SA license.
Klaatu interviews CrissiD and Charles, two organizers of FOSScon 2010. Listen to the ogg vorbis version of this interview courtesy your friends at the Bad Apples GNU Linux Oggcast.

hpr0588 :: Klaatu interviews Brian Smith from

Released on 2010-11-03 under a CC-BY-NC-SA license.
Klaatu An interview with Brian Smith SELF Interviews Klaatu interviews Brian Smith from Listen to the ogg vorbis version of this interview courtesy your friends at the Bad Apples GNU Linux Oggcast.

hpr0583 :: An interview with Alan Hicks

Released on 2010-10-27 under a CC-BY-NC-SA license.
Klaatu interviews Alan Hicks of Slackbook and the Slackware team about SELF 2010, Slackware 13.1, encryption, and the wifis Listen to the ogg vorbis version of this episode courtesy of teh Bad Applez.

hpr0579 :: Interview with Jeff and Loafy, two SELF volunteers

Released on 2010-10-21 under a CC-BY-NC-SA license.
Klaatu talks to Jeff and Loafy, two volunteers at SELF 2010. For the ogg version, click riiiight here.

hpr0576 :: Interview with HeathenX

Released on 2010-10-18 under a CC-BY-NC-SA license.

Klaatu, at the Ohio Linux Fest 2009, interviews HeathenX from the screencasters about art on Linux, Inkscape, GIMP, multi-platform applications, and more.

The ogg version provided by The Bad Apples.

hpr0574 :: Interview with Maco

Released on 2010-10-06 under a CC-BY-NC-SA license.
Klaatu interviews Maco about her new Sign Language Tutor application, Gally, as well as why Qt and KDE are better than all the rest, plus Ubuntu Women and women in computing, Linux and security, and some other stuff. Listen to this episode in ogg vorbis courtesy the Bad Applez.

hpr0572 :: Interview with Mark Zareason

Released on 2010-09-21 under a CC-BY-NC-SA license.

Klaatu talks to Mark from Zareason.

Wanna hear this episode in ogg? Sure ya do!

hpr0556 :: Basekamp Interview

Released on 2010-07-18 under a CC-BY-NC-SA license.
Klaatu talks to Meg and Scott from about possible art worlds, free culture, free software, economics, social organization, collaboration, and a lot more.

Find the ogg version courtesy your friends at the bad applez.

hpr0553 :: interview with celesteLynPaul

Released on 2010-07-10 under a CC-BY-NC-SA license.
klaatu interviews celesteLynPaul of the KDE project

hpr0551 :: Interview with Wendy Seltzer

Released on 2010-07-01 under a CC-BY-NC-SA license.
another interview from klaatu at SELF 2010

hpr0550 :: Interview with jledbetter

Released on 2010-06-25 under a CC-BY-NC-SA license.
klaatu interviews jledbetter a java developer

hpr0547 :: openCSW Interview

Released on 2010-06-07 under a CC-BY-NC-SA license.

Klaatu talks to Philip Brown of the openCSW project about Solaris, SunOS, portability and code, and lots more.

You may also listen to this episode in glorious ogg vorbis.

Word up! the anti-talkshoe producers of this episode: Timrit and cobra2

hpr0515 :: Network Basics Part 6

Released on 2010-02-11 under a CC-BY-NC-SA license.
Klaatu continues his network basics series

hpr0501 :: Klaatu interviews Rikki Kite of Linux Pro Magazine

Released on 2010-01-06 under a CC-BY-NC-SA license.

Klaatu, at the Ohio Linux Fest 2009. interviews Rikki Kite, associate publisher of Linux Pro Magazine.

The ogg version provided by The Bad Apple Linux Oggcast.

hpr0494 :: Klaatu interviews Russ from Linux in the Ham Shack

Released on 2009-12-11 under a CC-BY-NC-SA license.

Klaatu, at Ohio Linux Fest 2009, interviews Russ from the Linux in the Ham Shack podcast.

The ogg version provided by The Bad Apple Linux Oggcast.

hpr0484 :: Her PR Problem

Released on 2009-11-17 under a CC-BY-NC-SA license.

Rikki Kite of The Rose Blog and Linux Pro Magazine gives her "Her PR Problem" talk at Ohio Linux Fest 2009's Diversity in Open Source Workshop.

The ogg version provided by The Bad Apple Linux Oggcast.

hpr0479 :: OLF 2009: Interview with Dwick

Released on 2009-11-06 under a CC-BY-NC-SA license.

Klaatu at Ohio Linux Fest 2009 interviews DWick, a math professor, about math programs on Linux.

The ogg version kindly provided by The Bad Apples.

hpr0470 :: Interworx

Released on 2009-10-21 under a CC-BY-NC-SA license.
Klaatu interviews Jon from Interworx at Ohio Linux Fest 2009.

hpr0441 :: Migrating Your GPG Key and Starting GPG-Agent

Released on 2009-09-09 under a CC-BY-NC-SA license.
Klaatu continues his discussion of GnuPG related matters (see episode 0222 for Alpine+GPG and some random Bad Apple Linux OggCast ep 2x04 on GPG in general). In this exciting episode, he talks about the proper way to migrate your GnuPG keys, how to manage gpg-agent in your Slackware+KDE desktop, and advises everyone who will be attending Ohio Linux Fest this year to attend the GnuPG Key Signing Party.

hpr0435 :: Lightweight Apps: Enlightenment, Part 2

Released on 2009-09-01 under a CC-BY-NC-SA license.

Lightweight Apps: Enlightenment, Part 2

Klaatu and Bryanstein from the Florida Linux Show rave about e17.

Easy-E17 Install Script
This episode in ogg

hpr0434 :: HPR Roundtable 4

Released on 2009-09-01 under a CC-BY-NC-SA license.

Klaatu, Deepgeek, Charles from MintCast, Russ from the Techie Geek, Russ from The Linux Ham Shack, and Seal gather at the official HPR Round Table to discuss what free software apps they use to make life easier.

Projects mentioned in this episode:

Portable Ubuntu Remix


OpenSwan - IPsec for Linux


Mozilla Sunbird



Org Mode for Emacs


...and a LOT more...

You can also download this episode in the controversial ogg format.

hpr0432 :: How to use walkies

Released on 2009-08-27 under a CC-BY-NC-SA license.

If you're putting on an event such as a Linux Fest, a film production, an organized [a]political demonstration, then you may find yourself using walkies ("walkie talkies" or "CB Radios"). Klaatu talks all about walkies in this episode; deciding whether to buy or rent, how to use them effectively, how to use them efficiently, and other matters of etiquette & protocol.

You can also listen to this walkies episode in the free audio format, ogg vorbis.

hpr0423 :: Interview with Ian Geiser of the KDE Project

Released on 2009-08-14 under a CC-BY-NC-SA license.

Klaatu talks to Ian Geiser of the KDE project.

You can download this episode as an ogg file.
KDE dot News

hpr0416 :: Mer Project Interview

Released on 2009-08-06 under a CC-BY-NC-SA license.

Klaatu, at SELF, talks to Andrew from the Mer project, for the Nokia N770 and N8x0 tablets.

The Mer Project
This episode in ogg vorbis.

hpr0414 :: Networking Basics Part 5

Released on 2009-08-01 under a CC-BY-NC-SA license.

Klaatu goes over IP (Internet Protocol), its header information, the mechanics of datagram fragmentation, and RFC 791 in general.

see also RFC 791
iana protocol number assignments

Listen to this episode in ogg.

hpr0413 :: Ontario Linux Fest Interview

Released on 2009-07-30 under a CC-BY-NC-SA license.
p>Klaatu talks to Richard W. about Open Street Maps -- why it exists, why it's important, and what it's good for -- and the upcoming Ontario Linux Fest.

Download this episode in the ogg vorbis format.

hpr0411 :: Free Software Foundation Interview

Released on 2009-07-28 under a CC-BY-NC-SA license.

Klaatu talks to Deborah from the Free Software Foundation.

If you're gonna listen to an episode about the FSF, you may as well listen to the ogg vorbis version, no?

hpr0409 :: Bug Reporting

Released on 2009-07-24 under a CC-BY-NC-SA license.

In this exciting continuation of HPR Episode 92, Klaatu talks to Mackenzie at the SouthEast Linux Fest about bug reporting and bug triaging.

Download this here episode over yonder in the ogg vorbis format.

hpr0408 :: Interview with JonathanD from Freenode

Released on 2009-07-23 under a CC-BY-NC-SA license.

Klaatu talks to JonathanD of the Freenode network.

The Free-as-in-Node Podcast
The ogg version of this episode.

hpr0406 :: Moonshine

Released on 2009-07-21 under a CC-BY-NC-SA license.

While everyone else at the SouthEast Linux Fest was watching the fine closing keynote by Mr. Paul Frields, Klaatu was hanging out in the hallways talking to Cobra2 (of, Alan Hicks (from the Slackbook project), and a few other SELF attendees as they discuss howto make Moonshine. Bonus topics include Brunswick Stew, moonshine mash recipes, building transmissions, and trucks.

You can download this episode as an ogg file.

Editor's note 2017-11-25: unixporn link adjusted in accordance with comment 1.

hpr0404 :: Tikiwiki

Released on 2009-07-17 under a CC-BY-NC-SA license.

Klaatu installs Tiki Wiki, a simple but full-featured wiki software.

You may also listen to this episode in ogg vorbis.

hpr0402 :: Interview with Paul Frields of the Fedora Project

Released on 2009-07-15 under a CC-BY-NC-SA license.

Klaatu talks to Paul Frields (of the Fedora Project) about Linux in computer forensics and government.

You can also get this episode in ogg vorbis courtesy the good folks over at the Bad Apple Linux Ogg Cast.

hpr0394 :: Networking Basics Part 4 TCP and UDP

Released on 2009-07-03 under a CC-BY-NC-SA license.

Klaatu continues his Network Basics series. This episode covers TCP and UDP.

You can download the ogg version of this episode, or if you are using Firefox 3.5 then you can just listen to it right in your browser, by clicking here.

hpr0392 :: Interview with Dual Core

Released on 2009-07-01 under a CC-BY-NC-SA license.

Klaatu interviews int eighty and Remy from the group Dual Core.

You can download this interview as an ogg file.
Check out Dual Core on the world wide interwebs.

hpr0390 :: Interview with Alan Hicks

Released on 2009-06-29 under a CC-BY-NC-SA license.
Klaatu and Alan Hicks (from the Slackbook project) chat about Slackware, 64bit support, slack hacking methodology, what's in the works for Slackbook 3.0, Slackware' intended audience, the SouthEast Linux Fest, and more.

Check out the book that got Klaatu addicted to Slack, Slackware Essentials
Or check out the revised Slackware Book project online at
And check out Slackware itself at This episode is also available in ogg vorbis format.

hpr0388 :: Interview with Beth Lynn of OLF

Released on 2009-06-25 under a CC-BY-NC-SA license.

Klaatu first debates with his SouthEast Linux Fest pal, 8 year old Ethan, about where to conduct interviews...then talks to Beth Lynn about Ohio Linux Fest 2009 and all the new and exciting events planned for it!

Get the ogg version of this episode by clicking on this link

hpr0384 :: Red Hat Interview

Released on 2009-06-19 under a CC-BY-NC-SA license.

Klaatu talks to Eric from Red Hat about RHEL, Fedora, Linux in tha corporate world, and how proprietary blockades to adopting free software can be worked around for those of us who wear ties to work.

Speaking of proprietary can download this episode as an ogg file.
For extra credit, check out Red Hat's blog.

hpr0383 :: TOR Interview

Released on 2009-06-18 under a CC-BY-NC-SA license.

Klaatu talks to Wendy Seltzer of the TOR project about...the TOR project. Please note that even though Klaatu continually refers to the TOR Project as "The Onion Router", officially the TOR Project is now properly referred to as simply "the TOR Project".

You can download the ogg vorbis version of this episode from the Bad Apples.

hpr0379 :: SSL Ep 1

Released on 2009-06-12 under a CC-BY-NC-SA license.

Klaatu reveals the mysteries of SSL certifications and why self-signing is not such a bad thing after all. - the self signing collective

The ogg vorbis version of this episode can be downloaded here.

hpr0373 :: Qemu

Released on 2009-06-04 under a CC-BY-NC-SA license.

Klaatu, on vacation in Niagra Falls (or so it sounds from all the background noise...), talks about Qemu.

Qemu Pre-built Virtual Machines to run with Qemu

You may also choose to download the ogg version.

hpr0363 :: Networking Basics Part 3

Released on 2009-05-22 under a CC-BY-NC-SA license.

In the third episode of Basic Networking, Klaatu talks about all things Ethernet; from the physical construction of the cables to the structure of the data frames being sent over them.

As usual, an ogg version is available over on the bad apples.

hpr0357 :: Network Basics Part 2

Released on 2009-05-13 under a CC-BY-NC-SA license.

In episode 2 of Networking Basics, Klaatu covers Routers, Switches, and Hubs. He also discusses the concepts of Collision Domains and Broadcast Domains.

The ogg version is available here.

hpr0351 :: Network Basics

Released on 2009-05-05 under a CC-BY-NC-SA license.
klaatu talks about basic networking

hpr0338 :: cappuccino

Released on 2009-04-16 under a CC-BY-NC-SA license.

Klaatu reveals the methodology and secrets of making the perfect cappuccino.

Here's the ogg version.

hpr0329 :: SSH Part 2

Released on 2009-04-03 under a CC-BY-NC-SA license.

HOWTO use ssh keys and ssh-agent to provide easier SSH'ing in your network!

Listen carefully for bonus subliminal messages delivered by Klaatu's friend's (black) cat.

This episode also available in ogg.,/a>

hpr0307 :: Krita

Released on 2009-03-04 under a CC-BY-NC-SA license.
Klaatu compares Krita, Gimp and, obligatorily, Ph0t0sh0p.

hpr0287 :: sysctl

Released on 2009-02-04 under a CC-BY-NC-SA license.
Klaatu talks about the lil' kernel paramater command "sysctl" and how it enables your computer to stop responding to pings, and more.

ogg version located at

hpr0269 :: Cups

Released on 2009-01-09 under a CC-BY-NC-SA license.
klaatu talks about printing in linux

hpr0244 :: Enlightment

Released on 2008-12-05 under a CC-BY-NC-SA license.

Klaatu hijacks deepgeek's "Lightweight App" series and discusses one of his favourite lightweight desktop environments.

You can also choose to download Klaatu's ogg version of this episode.

hpr0237 :: Creating Identification Cards Part 2

Released on 2008-11-26 under a CC-BY-NC-SA license.
p>Klaatu talks about using the phone company as a leaping-off point toward a new You! Also, gift cards and spreading the word about your new identity.

Get Klaatu's ogg version of this show if you hatez the MPEG.

hpr0234 :: Creating Identification Cards Part 1

Released on 2008-11-21 under a CC-BY-NC-SA license.

Get yer supplies at Poison ID .
A simple laminator example is the ABC HeatSeal

Download the ogg version if you are a codec snob.

hpr0228 :: nokia

Released on 2008-11-13 under a CC-BY-NC-SA license.

Klaatu talks about setting up your Nokia N8*0 or N770 to be a robust computing platform, and the importance of doing so before you need it rather than waiting, like he does, until the last minute and scrambling to get all the packages you need installed. He concedes that he's failed to mention a lot of cool apps, so feel free to make suggestions in the comments.

Nokia N-series Repository Site

You can also download Klaatu's ogg version of this episode if you prefer ogg.

hpr0223 :: git

Released on 2008-11-06 under a CC-BY-NC-SA license.

Klaatu talks about how to set up, navigate within, commit, and push with git. This is a beginner level howto that will also help you understand SVN and CVS.

More information about git and similar apps can be found here: git tutorial
CVS, another versioning system

You can also download the ogg version of this episode.

hpr0222 :: Alpine GPG

Released on 2008-11-05 under a CC-BY-NC-SA license.

For more info on PGP and GPG:
The Bad Apples episode 2x04 ogg
The Bad Apples episode 2x04 mp3
Linux Reality episode 47

you can also download the OGG version of this episode.

hpr0207 :: Vulgar Esperantist Part 3

Released on 2008-10-15 under a CC-BY-NC-SA license.
klaatu continues his Vulgar Esperantist series

hpr0203 :: Alpine: How to

Released on 2008-10-09 under a CC-BY-NC-SA license.

Klaatu talks about the virtues of the Alpine (or Pine) email client, how to set it up, special settings for using it with IMAP servers, how to configure the reply-to address correctly, and much more.

Alpine Official Site Pine Official Site OGG version

hpr0197 :: Vulgar Esperantist Part 2

Released on 2008-10-01 under a CC-BY-NC-SA license.
klaatu continues his Vulgar Esperantist series

hpr0186 :: Vulgar Esperantist part 1

Released on 2008-09-16 under a CC-BY-NC-SA license.
klaatu's first part in his "Vulgar Esperantist" series done for the LinguistChat web series

hpr0181 :: Setting up vsFTPD

Released on 2008-09-09 under a CC-BY-NC-SA license.

Klaatu talks about setting up an FTP server.

vsFTPd site
ogg version

hpr0173 :: Configuring Pulse Audio

Released on 2008-08-28 under a CC-BY-NC-SA license.

Klaatu and notJlindsay discuss Pulse Audio and how to configure it so it doesn't bork your system. One thing Klaatu fails to mention is that before you try any of this, you should just run whatever software updates may be available for your OS. Pulse configuration and compatability seems to be improving rapidly over time, so many thing may "fix themselves" by simply making sure your distro is up to date.

Wiki Article
the ogg version of this episode

hpr0166 :: 10 Minute Mail

Released on 2008-08-19 under a CC-BY-NC-SA license.

10 Minute Mail
Ogg Version of this Episode

hpr0152 :: Pulse Audio Intro

Released on 2008-07-30 under a CC-BY-NC-SA license.

Klaatu interviews Kajarii about Pulse Audio.

Pulse Audio Website

Since I'll be listening to this episode in OGG format, I figured I'd post the ogg version in case anyone else wants it. --klaatu

hpr0149 :: DynamicDNS

Released on 2008-07-25 under a CC-BY-NC-SA license.
klaatu talks about dynamic dns

hpr0139 :: Compiling a Kernel over the Nework with distcc

Released on 2008-07-14 under a CC-BY-NC-SA license.
klaatu talks about compiling a Kernel over the network with distcc.

hpr0134 :: Kernal Patching

Released on 2008-07-07 under a CC-BY-NC-SA license.
Part 2 of the How to Build your own Kernal Series

hpr0108 :: Handbrake - Howto

Released on 2008-05-29 under a CC-BY-NC-SA license.
The podcasting machine hosts another episode of hacker public radio

hpr0092 :: bugs

Released on 2008-05-07 under a CC-BY-NC-SA license.
klaatu talks about bug reporting and bug triaging.

hpr0087 :: Compling a Kernel

Released on 2008-04-30 under a CC-BY-NC-SA license.
get the latest Linux kernel source code download Dave Yates's Kernel Compile Episode Peter64's Kernel Compile Monsterb's Kernel Compile

hpr0080 :: Coffee

Released on 2008-04-21 under a CC-BY-NC-SA license.
klaatu talks about coffee

hpr0072 :: Imagemagick

Released on 2008-04-09 under a CC-BY-NC-SA license.
klaatu gives a review of Imagemagick

hpr0061 :: Punk Computing

Released on 2008-03-25 under a CC-BY-NC-SA license.
How not to get stuck by the man, while sticking it to the man.

Shownotes by: diggsit

hpr0059 :: Interview with scorche

Released on 2008-03-21 under a CC-BY-NC-SA license.
Interview with scorche from the Rockbox Project

hpr0055 :: Slax

Released on 2008-03-17 under a CC-BY-NC-SA license.

hpr0053 :: Codecs Part 4

Released on 2008-03-13 under a CC-BY-NC-SA license.
In this final episode of the series, Klaatu covers some proprietary codec packages. He then explains how to use free software and the linux command line to transcode a video using the open codec, Theora.

Shownotes by: diggsit

hpr0041 :: Codecs Part 3

Released on 2008-02-26 under a CC-BY-NC-SA license.
Codecs aren't containers. Klaatu explains the difference. He also presents some legal and technical factors to consider when choosing a codec.

Shownotes by: diggsit

hpr0029 :: Codecs Part 2

Released on 2008-02-07 under a CC-BY-NC-SA license.
Klaatu continues his four-part series. This episode focuses on the technique of video compression. He explains the variables involved, and how they relate to file size and delivery method.

Shownotes by: diggsit

hpr0026 :: Intro to codecs

Released on 2008-02-04 under a CC-BY-NC-SA license.
In this first of a four-part series, Klaatu begins a discussion of free and non-free video codecs. Specifically, why they are needed and how they work.

Shownotes by: diggsit

Become a Correspondent