Hobby Public Radio

Correspondent

klaatu

Host ID: 78

gnuworldorder.info

hpr2672 :: Porteus

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:

$ 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-installer-for-Linux.com
# ./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.

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.

hpr2667 :: Create PDF bookmarks with Pdftk

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:

InfoBegin
InfoKey: ModDate
InfoValue: D:20181010181951-05'00'
InfoBegin
InfoKey: CreationDate
InfoValue: D:20181010181934-05'00'
InfoBegin
InfoKey: Creator
InfoValue: pdftk (Linux)
InfoBegin
InfoKey: Producer
InfoValue: pdftk 2.02-x86_64
PdfID0: d8deadbeeff34211ba60d80fda7611da
PdfID1: 39186170c6134566884b79c0ffee7d59
NumberOfPages: 261
BookmarkBegin
BookmarkTitle: Cover
BookmarkLevel: 1
BookmarkPageNumber: 1
BookmarkBegin
BookmarkTitle: Credits
BookmarkLevel: 1
BookmarkPageNumber: 2
BookmarkBegin
BookmarkTitle: Chapter One
BookmarkLevel: 1
BookmarkPageNumber: 3
BookmarkBegin
BookmarkTitle: Foo Section
BookmarkLevel: 2
BookmarkPageNumber: 5
BookmarkBegin
BookmarkTitle: Bar Baz
BookmarkLevel: 3
BookmarkPageNumber: 7
BookmarkBegin
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

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

See rpggeek.com/thread/532036/how-build-deck-magic-gathering by Eric Jome for a good deck building formula.

hpr2634 :: Git tag and metadata

Tag a commit:

$ git tag 0.1
$ git tag
0.1

Delete a tag:

$ git tag -d 0.1

Get the latest commit hash:

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

Get any tag on a commit:

$ git describe --tags 94c5715
0.1

hpr2613 :: Quick Awk Tip

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:

#!/usr/bin/awk

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

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

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

• 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

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.

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

void draw() {
    rect(10,10,80,80);
}

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

Add some colour to your rectangle:

void draw() {
    fill(8,120,90);
    rect(10,10,80,80);
}

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

Make a simple painting app:

void setup() {
    size(480,720);
}

void draw() {
    if (mousePressed) {
        fill(20,120,90);
        ellipse(mouseX,mouseY,25,25);
    } else {
        fill(random(10,120),random(10,80),random(20,200));
    }
}

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

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

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

Public domain music from archive.org. 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

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

hpr2573 :: Foundations of git rebase

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
master
$ 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

Details about Kill Doctor Lucky on Paizo.com.

hpr2569 :: Pandemic: Reign of Cthulu board game review

Pandemic Reign of Cthulu

Pandemic original edition

Mods can be found online. For instance: fractuslearning.com/pandemic-board-game

hpr2568 :: Personal finance

Personal finances

Problem

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:

0. 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: http://etrade.com or http://fidelity.com
• In other countries, look for brokers who will invest your money in local or international markets

hpr2564 :: Intro to Fossil

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

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

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

and

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

hpr2550 :: Howto get started playing RPGs

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

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

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

git add

git commit -m "some useful message"

git push origin HEAD

hpr2461 :: Gitolite

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

hpr2455 :: Interface Zero RPG Part 5

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

Music

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

• All other music by Klaatu.

Story

Want to play this game yourself?

• Pathfinder and Starfinder are by Paizo

• Interface Zero module available from driveThruRPG.com

• Adventure path Job inSecurity is available from driveThruRPG.com.

• The source of the story is available from driveThruRPG.com

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

hpr2451 :: Server Basics 105 OpenVPN Client

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

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

A sample post-receive git hook:

#!/usr/bin/tcsh

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

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."
      else
        echo "Do something entirely different here."
    endif

hpr2444 :: Interface Zero Play-through Part 4

The investigation continues!

Guest voice in this and episode 3 by Gort.

hpr2441 :: Server Basics 103

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

• firewalld

• fail2ban

hpr2437 :: Interface Zero Play-through Part 3

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 freesound.org used for texture. Obligatory credits will appear in final episode.

hpr2435 :: Server Basics 102

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

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.

hpr2428 :: git Blobs

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

In this episode, Klaatu explains two popular options:

• git-media

• git-annex

Thanks to CapsLok at freesound.org for the sound effect.

hpr2427 :: Server Basics 101

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

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

Requirements

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

Here is some sample XML for you:

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

  <para>
    You're listening to <emphasis role="bold">Hacker Public
    Radio</emphasis>.
  </para>
</xml>

And here's the complete XSL as demonstrated:

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">

  <xsl:template match="para">
    <p><span><xsl:apply-templates/></span></p>
  </xsl:template>

  <xsl:template match="emphasis">
    <em><xsl:apply-templates/></em>
  </xsl:template>

  <xsl:template match="emphasis[@role='bold']">
    <strong><xsl:apply-templates/></strong>
  </xsl:template>

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

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

      <xsl:when test="$host = 'Gort'">
        <xsl:text>Gort</xsl:text>
      </xsl:when>
    </xsl:choose>
  </xsl:template>
</xsl:stylesheet>

Links

• Norm Walsh

• dpawson

• O'Reilly

• DM Schema

hpr2424 :: Interface Zero RPG Play

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

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

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 https://www.kickstarter.com/projects/s8hzk27aqx/petition-a-card-game-for-fanatics

hpr2390 :: Still in the game

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

hpr2381 :: Benefits of a tabletop

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

hpr2378 :: Why Docbook?

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

hpr2373 :: PCGen

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

hpr2372 :: Docbook

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

hpr2361 :: Information Underground: Working Out

Deepgeek, Lostnbronx, and Klaatu talk about exercise.

hpr2313 :: NilFS2

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

http://nilfs.sourceforge.net/en/

hpr2282 :: Pathfinder Adventure Card Game

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

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

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

hpr2178 :: Dice Mixer

Klaatu reviews the Dice Mixer.

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

hpr2174 :: Dungeoneer Tabletop Game

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

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

Game design by Hazel "Skip" Bowman.

http://boardgamegeek.com/boardgame/1269/skip-bo

hpr2159 :: Coup Tabletop Game

https://www.kickstarter.com/projects/2012515236/coup-bluff-and-deception-in-the-world-of-the-resis

hpr2152 :: Apples to Apples Tabletop Game

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

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

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

Links in this show:

• https://pip.pypa.io/en/stable/installing/

• http://flask.pocoo.org/

hpr2136 :: Fluxx Tabletop Game

Klaatu reviews the card game series, Fluxx.

http://boardgamegeek.com/geeksearch.php?action=search&objecttype=boardgame&q=fluxx&B1=Go

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

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

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

[Unit]
Description=Fake-Halt Service
After=fakevm.service
Requires=fakevm.service

[Service]
Type=simple
ExecStart=/usr/local/bin/fakehalt.sh #this will fail until fakevm succeeds
ExecReload=/usr/local/bin/fakehalt.sh

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

# cat /lib/systemd/system/fakevm.service
[Unit]
Description=Fake Service
Before=fakehalt.service

[Service]
Type=simple
ExecStart=/usr/local/bin/fake.sh

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

# cat /usr/local/bin/fake.sh
#!/bin/sh

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

And a script to pass for a shutdown signal:

# cat /usr/local/bin/fakehalt.sh
#!/bin/sh

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

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

http://boardgamegeek.com/boardgame/12692/gloom

hpr2130 :: Git push to two repositories at once

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

Klaatu ponders analogue programming and tabletop gaming.

hpr2121 :: Dark Cults Tabletop Game

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

hpr2013 :: Parsing XML in Python with Xmltodict

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"?>
<book>
   <chapter id="prologue">
      <title>
     The Beginning
  </title>
      <para>
     This is the first paragraph.
      </para>
    </chapter>

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

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:

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

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.

Attributes

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']
'prologue'

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']
...
'prologue'
'end'

Contents

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"?>
<book>
   <chapter id="prologue">
      <title>
     The Beginning
  </title>
      <para class="linux">
     This is the first paragraph.
      </para>
    </chapter>

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

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(g.read())
>>> 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.'

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.

[EOF]

Made on Free Software.

hpr2012 :: Parsing XML in Python with Untangle

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"?>
<book>
   <chapter id="prologue">
      <title>
     The Beginning
 </title>
   </chapter>
</book>

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:

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

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

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

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

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

>>> data.book.chapter[0]
Element(name = chapter, attributes = {'id': 'prologue'}, cdata = )
>>> data.book.chapter[1]
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:

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

>>> data.book.chapter[0].title.cdata.strip()
'The Beginning'
>>> data.book.chapter[1].title.cdata.strip()
'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:

>>> data.book.chapter[0].para.cdata.strip()
'This is the first paragraph.'
>>> data.book.chapter[1].para.cdata.strip()
'Last para of last chapter.'

You can also iterate over items:

>>> COUNT = [0,1]
>>> for TICK in COUNT:
...     print(data.book.chapter[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.

[EOF]

Made on Free Software.

hpr2010 :: Parsing JSON with Python

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:

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

json_data.close()

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!

[EOF]

Made with Free Software.

hpr1942 :: Kobo Touch N-905 E-Reader

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:

http://gedakc.users.sourceforge.net/display-doc.php?name=kobo-desktop-ereader-setup

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

Good:

• 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

Negative

• 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

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.

http://www.cloudera.com/
https://hadoop.apache.org/

hpr1932 :: Klaatu interviews Grafana

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.

http://grafana.org

hpr1927 :: Ansible Interview

Klaatu talks to Ansible at All Things Open conference.

hpr1923 :: Klaatu and System76

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

https://system76.com/

hpr1917 :: OpenSource.com

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!

hpr1912 :: OpenNMS at All Things Open Conference

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

hpr1907 :: Charlie Reisinger and Penn Manor

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

hpr1880 :: Arduino Bluetooth HOWTO

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)

hpr1856 :: ssh config

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
    hostname foo.org
    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 klaatu@foo.org

hpr1691 :: Arduino 101 Arduino IO

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:

• https://openclipart.org/detail/104167/breadboard-by-mesamike
• https://openclipart.org/detail/181334/microcontroller--by-b.gaultier-181334

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

The simple code to reset the servo:

#include <Servo.h>
Servo myservo;

int servoPosition;

void setup()
{
  myservo.attach(13);
  myservo.write(90);
}

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()
{
  myservo.attach(13);
}

void loop() 
{
  value = analogRead(0);
  servoPosition = map(value, valMin, valMax, servoMax, servoMin);
  servoPosition = constrain(servoPosition, servoMin, servoMax);
  myservo.write(servoPosition);
}

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

hpr1690 :: Arduino 101 Breadboard

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:

• https://openclipart.org/detail/104167/breadboard-by-mesamike
• https://openclipart.org/detail/181334/microcontroller--by-b.gaultier-181334

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

hpr1668 :: Nixstaller

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 http://nixstaller.sourceforge.net and read the docs there.

Review the sample package templates included in the examples dir.

Generate an empty template dir with genprojdir.sh

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.sh:

geninstall foo-1.0.0 foo.run

That's it!

hpr1616 :: Howto Use Webfonts

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

hpr1606 :: Howto VNC

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

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

hpr1596 :: About the Word "Hack"

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

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.

Links

CMU CREATE Lab

hpr1574 :: Arts and Bots

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.

Links

CMU CREATE Lab

hpr1522 :: How to Use Docker and Linux Containers

How to use Docker and Linux Containers

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

Steam OS or Steam on Linux, anti-micro for game controller optimisation.
Part 2 of 2
http://straightedgelinux.com/blog/opinions/box.html

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

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

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

In this episode Klaatu discusses the Art of Computing.

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

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

Links

Set up GnuPG: http://straightedgelinux.com/blog/howto/setupgnupg.html

Using Mutt: http://straightedgelinux.com/blog/howto/mutt.html

Klaatu's humble dot-muttrc file: http://gnuworldorder.info/dot-muttrc (there are better ones out there)

Klaatu's public key

hpr1277 :: Icecast 102

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:

http://slackermedia.info/radio

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

hpr1272 :: Open Badges?

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

Links

openbadges.org

hpr1259 :: Cyanide Cupcake and Klaatu

Cyanide Cupcake talks to Klaatu about the Scratch programming language.

Links

• http://scratch.mit.edu/
• http://scratched.media.mit.edu/
• http://slackermedia.info/slackbuilds

hpr1207 :: Icecast 101

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">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <title>My Great Streaming Server Example dot Com</title>
</head>
<div id="player">
<audio width="100px" height="200px" autoplay loop controls autobuffer preload="auto">
      <source src="http://example.com:8000/mp3" type="audio/mp3" />
      <source src="http://example.com:8000/ogg" type="audio/ogg" />
</audio>
</div>
  </body>
</html>

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

hpr1188 :: Rmail in Emacs

11 hours to go. 235 funders Contributed $8,633 USD of $20,000 43%
Donate here http://www.indiegogo.com/projects/sonar-project

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

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

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

Klaatu continues his Networking Basics series with a SAMBA howto.
http://samba.org

hpr0882 :: RPM format

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.

Fedora Project RPM HOWTO

Maximum RPM at rpm.org

yesplz.spec

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

hpr0876 :: Packaging applications: BSD ports

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.

FreeBSD Porter's Handbook

yesplz port

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

hpr0872 :: Packaging YUM

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

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.

Links

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.

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

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

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.

http://www.slackware.com/
http://en.wikipedia.org/wiki/Patrick_Volkerding
http://en.wikipedia.org/wiki/Slackware

hpr0852 :: GNU Emacs 1

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

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

http://fedoraproject.org/wiki/Fedora_Project_Wiki
http://www.jaredsmith.net/

hpr0841 :: Jonathan Nadeau

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

Klaatu interviews Jeff from No Machine.

hpr0831 :: Chris from Sourceforge.net

Klaatu interviews Chris from Sourceforge.net, at the Ohio Linux Fest.

hpr0827 :: HPR booth and HostGator

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

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

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

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

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

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.

SlackBuilds.org

yesplz_aug_4_2010.tgz source

yesplz slackbuild

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

hpr0793 :: Server/Client relationship, DHCP server

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

klaatu talks to Jason DeRose about NovaCut (http://novacut.com/)
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
http://www.kickstarter.com/projects/novacut/novacut-pro-video-editor

hpr0767 :: Maddog and "super dumb terminals"

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

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 SlackBuilds.org mailing list

Klaatu talks to /dev/Rob0, a Slackware user, maintainer of the SlackBuilds.org 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

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 gitorious.org/trashy

hpr0727 :: HOWTO root and mod an Andr0id phone.

Klaatu's HOWTO root and mod an Andr0id phone.

Links:

• developer.android.com/sdk
• addictivetips.com
• addictivetips.com/mobile/how-to-install-clockwork-recovery-to-your-android-phone
• cyanogenmod

This episode is also available in ogg vorbis.

hpr0723 :: How to be a safe computerist

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

Klaatu talks to Mark, aka deltaRay, from CLI Magic and suso.com 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

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

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

hpr0638 :: Urban Camping ep 6

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

hpr0634 :: Urban Camping ep 5

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

hpr0626 :: Urban Camping ep 4

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

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

Klaatu talks to Tek Systems at SELF 2010. Listen to the ogg vorbis version courtesy of the Bad Applez.

hpr0615 :: Urban Camping ep 2

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

hpr0607 :: Klaatu talks to Rebecca from bueda.com

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

hpr0602 :: Urban Camping ep 1

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

Trombone sample from freesound.org catalogue number 73581
End song by Jimmy Rogers, courtesy archive.org

hpr0592 :: FOSScon: An interview with CrissiD and Charles

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.

http://www.fosscon.org
http://www.thebadapples.info/audiophile/hpr_fosscon2010.ogg
http://www.thebadapples.info

hpr0588 :: Klaatu interviews Brian Smith from dns.com

Klaatu An interview with Brian Smith SELF Interviews Klaatu interviews Brian Smith from dns.com. 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

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

Klaatu talks to Jeff and Loafy, two volunteers at SELF 2010. For the ogg version, click riiiight here.

hpr0576 :: Interview with HeathenX

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

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

Klaatu talks to Mark from Zareason.

Wanna hear this episode in ogg? Sure ya do!

hpr0556 :: Basekamp Interview

Klaatu talks to Meg and Scott from Basekamp.com 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

klaatu interviews celesteLynPaul of the KDE project

hpr0551 :: Interview with Wendy Seltzer

another interview from klaatu at SELF 2010

hpr0550 :: Interview with jledbetter

klaatu interviews jledbetter a java developer

hpr0547 :: openCSW Interview

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

Klaatu continues his network basics series

hpr0501 :: Klaatu interviews Rikki Kite of Linux Pro Magazine

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

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

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

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

Klaatu interviews Jon from Interworx at Ohio Linux Fest 2009.

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

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

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

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

Xming

OpenSwan - IPsec for Linux

Handbrake

Mozilla Sunbird

Filezilla

Celtx

Org Mode for Emacs

gVim

...and a LOT more...

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

hpr0432 :: How to use walkies

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

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

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

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

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

Klaatu talks to Deborah from the Free Software Foundation.

The FSF
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

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

Klaatu talks to JonathanD of the Freenode network.

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

hpr0406 :: Moonshine

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.

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

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

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

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

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

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 slackbook.org
And check out Slackware itself at slackware.com This episode is also available in ogg vorbis format.

hpr0388 :: Interview with Beth Lynn of OLF

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.

hpr0384 :: Red Hat Interview

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 blockades...you can download this episode as an ogg file.
For extra credit, check out Red Hat's blog.

hpr0383 :: TOR Interview

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

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

CAcert.org - the self signing collective

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

hpr0373 :: Qemu

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

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

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

klaatu talks about basic networking

hpr0338 :: cappuccino

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

Here's the ogg version.

hpr0329 :: SSH Part 2

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

Klaatu compares Krita, Gimp and, obligatorily, Ph0t0sh0p.

hpr0287 :: sysctl

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 http://www.thebadapples.info/audiophile/sysctl.ogg

hpr0269 :: Cups

klaatu talks about printing in linux

hpr0244 :: Enlightment

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

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

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

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

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.or.cz
kernel.org git tutorial
CVS, another versioning system
Subversion

You can also download the ogg version of this episode.

hpr0222 :: Alpine GPG

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

klaatu continues his Vulgar Esperantist series

hpr0203 :: Alpine: How to

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

klaatu continues his Vulgar Esperantist series

hpr0186 :: Vulgar Esperantist part 1

klaatu's first part in his "Vulgar Esperantist" series done for the LinguistChat web series

hpr0181 :: Setting up vsFTPD

Klaatu talks about setting up an FTP server.

vsFTPd site
ogg version

hpr0173 :: Configuring Pulse Audio

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

10 Minute Mail
Ogg Version of this Episode

hpr0152 :: Pulse Audio Intro

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

klaatu talks about dynamic dns

hpr0139 :: Compiling a Kernel over the Nework with distcc

klaatu talks about compiling a Kernel over the network with distcc.

hpr0134 :: Kernal Patching

Part 2 of the How to Build your own Kernal Series

hpr0108 :: Handbrake - Howto

The podcasting machine hosts another episode of hacker public radio

hpr0092 :: bugs

klaatu talks about bug reporting and bug triaging.

hpr0087 :: Compling a Kernel

get the latest Linux kernel source code download Dave Yates's Kernel Compile Episode Peter64's Kernel Compile Monsterb's Kernel Compile

hpr0080 :: Coffee

klaatu talks about coffee

hpr0072 :: Imagemagick

klaatu gives a review of Imagemagick

hpr0061 :: Punk Computing

How not to get stuck by the man, while sticking it to the man.

Shownotes by: diggsit

hpr0059 :: Interview with scorche

Interview with scorche from the Rockbox Project

hpr0055 :: Slax

http://www.slax.org
http://en.wikipedia.org/wiki/St._patricks_day

hpr0053 :: Codecs Part 4

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.
http://theora.org/
http://linuxreviews.org/man/ffmpeg2theora/

Shownotes by: diggsit

hpr0041 :: Codecs Part 3

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

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

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