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).

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

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

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.

When you open the resulting file (matrix.org 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!

Klaatu

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:

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

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

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.

Lostnbronx

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.

Klaatu

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 http://drivethrurpg.com, http://dmsguild.com, and https://www.opengamingstore.com

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.

Klaatu

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.

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.

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}
{A} Reinforced
{Z}
{A} Returned
{B...Y}
{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.

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.

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.

Install

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 porteus.org are not accurate). Assuming you have discovered, using lsblk, that your target device (the thumbdrive) is /dev/sdx:

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.

Boot

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

Miscellany

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.

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:

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.

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 Gitlab.com.

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.

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 gitlab.com/notklaatu/foo.git 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

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.

Get Processing from processing.org. 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() {
size(480,720);
}

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.

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?

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.

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).

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.

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

Installing OpenVPN on a client machine.

Generating a key and certificate request.

Signing a client cert from the server.

Configuring the client.conf file.

Configuring the client routing table to use the VPN subnet.

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!

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.

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 member.fsf.org). 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.

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.

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.

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).
https://en.wikipedia.org/wiki/NILFS

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.

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.

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.

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:

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

Install

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

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:

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."}]
}}'

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:

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.'

Advanced

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 github.com/martinblech/xmltodict.

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.

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.

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:

>>> data.book
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:

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 (data.book.chapter.title) and we have the contents of our current position.

Sniping

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:

>>> data.book.chapter['id']
'prologue'

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:

>>> data.book.chapter.title.cdata.strip()
'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:

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.

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:

{
"name":"tux",
"health":"23",
"level":"4"
}

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

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.

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.

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:

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.

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.

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.

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

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:
https://gitlab.com/makerbox/rovcon
(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)

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

Virtual Network ComputingFrom 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.

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.
https://en.wikipedia.org/wiki/LAMP_%28software_bundle%29

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 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 ProtocolFrom 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.https://en.wikipedia.org/wiki/Apple_Filing_Protocol

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.

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.

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.

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.

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.

Slackware

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.

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.

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.

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.

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 HostGator.com

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.

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 archive.org

Klaatu talks to Rebecca from bueda.com 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

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.

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.

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.

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.

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 unixporn.com), 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.

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 right.....here.

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.

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.

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.