Flaws In Progress

Today's Piece Of Advice For Programmers

noreply@blogger.com (Darryl L. Pierce) — Mon, 16 Mar 2020 13:58:00 +0000

If you're going to add a static method to a class that takes as input an instance of the class and some data to update the state of that instance, then why no make it an instance method? That way, when someone needs to refactor the code, they won't sit and wonder why you did such a thing and question your abilities as a developer.

Maven And Spring Boot: Get Maven Plugin Command Line Options

noreply@blogger.com (Darryl L. Pierce) — Thu, 09 Jan 2020 15:55:00 +0000

One of the issues I hit regularly is remembering the various command line arguments that can be sent to the Maven Spring Boot plugin. Specifically, arguments to be passed to the underlying application when I'm doing:

$ mvn spring-boot:run

To find the list of options, use the following command line:

$ mvn help:describe -Dcmd=spring-boot:run -Ddetail

Which outputs the following:

Mojo: 'spring-boot:run'
spring-boot:run
Description: Run an executable archive application.
Implementation: org.springframework.boot.maven.RunMojo
Language: java
Bound to phase: validate
Before this goal executes, it will call:
    Phase: 'test-compile'

Available parameters:

    addResources (Default: false)
      User property: spring-boot.run.addResources
      Add maven resources to the classpath directly, this allows live in-place
      editing of resources. Duplicate resources are removed from target/classes
      to prevent them to appear twice if ClassLoader.getResources() is called.
      Please consider adding spring-boot-devtools to your project instead as it
      provides this feature and many more.

    agent
      User property: spring-boot.run.agent
      Path to agent jar. NOTE: the use of agents means that processes will be
      started by forking a new JVM.

    arguments
      User property: spring-boot.run.arguments
      Arguments that should be passed to the application. On command line use
      commas to separate multiple arguments.

    classesDirectory (Default: ${project.build.outputDirectory})
      Required: true
      Directory containing the classes and resource files that should be
      packaged into the archive.

    environmentVariables
      List of Environment variables that should be associated with the forked
      process used to run the application. NOTE: the use of Environment
      variables means that processes will be started by forking a new JVM.

    excludeGroupIds
      User property: spring-boot.excludeGroupIds
      Comma separated list of groupId names to exclude (exact match).

    excludes
      User property: spring-boot.excludes
      Collection of artifact definitions to exclude. The Exclude element
      defines a groupId and artifactId mandatory properties and an optional
      classifier property.

    folders
      User property: spring-boot.run.folders
      Additional folders besides the classes directory that should be added to
      the classpath.

    fork
      User property: spring-boot.run.fork
      Flag to indicate if the run processes should be forked. fork is
      automatically enabled if an agent, jvmArguments or working directory are
      specified, or if devtools is present.

    includes
      User property: spring-boot.includes
      Collection of artifact definitions to include. The Include element
      defines a groupId and artifactId mandatory properties and an optional
      classifier property.

    jvmArguments
      User property: spring-boot.run.jvmArguments
      JVM arguments that should be associated with the forked process used to
      run the application. On command line, make sure to wrap multiple values
      between quotes. NOTE: the use of JVM arguments means that processes will
      be started by forking a new JVM.

    mainClass
      User property: spring-boot.run.main-class
      The name of the main class. If not specified the first compiled class
      found that contains a 'main' method will be used.

    noverify
      User property: spring-boot.run.noverify
      Flag to say that the agent requires -noverify.

    profiles
      User property: spring-boot.run.profiles
      The spring profiles to activate. Convenience shortcut of specifying the
      'spring.profiles.active' argument. On command line use commas to separate
      multiple profiles.

    skip (Default: false)
      User property: spring-boot.run.skip
      Skip the execution.

    systemPropertyVariables
      List of JVM system properties to pass to the process. NOTE: the use of
      system properties means that processes will be started by forking a new
      JVM.

    useTestClasspath (Default: false)
      User property: spring-boot.run.useTestClasspath
      Flag to include the test classpath when running.

    workingDirectory
      User property: spring-boot.run.workingDirectory
      Current working directory to use for the application. If not specified,
      basedir will be used. NOTE: the use of working directory means that
      processes will be started by forking a new JVM.

And then, specifically, to provide arguments to the underlying application, you would use:

$ mvn spring-boot:run -Dspring-boot.run.arguments=[the list of comma separated options]

Angular, NgRx And Adaptors: Separating State From Observers

noreply@blogger.com (Darryl L. Pierce) — Wed, 08 Jan 2020 16:39:00 +0000

In this post I'm going to discuss a model we've developed on my open source project as well as in my day job. With it we hide the details for state management in an Angular application that is using NgRx stores and effects.

Overview

When working with NgRx, one of the issues to solve is to provide state management without too tightly coupling the details of that state with the components that benefit from it. You want to avoid having your components reacting to every change in that state when the changes are of no interest to that component's area of concern. For example, if your application has a state for managing the currently authenticated user, you may not want your navigation bar have to process a state update at any time other than when the user's name or email address is changed or if their authentication state changes.

The goal of this pattern is to hide the details of that state management inside of an injectable class that maintains knowledge of that state, provides methods to initiate actions and observables to allow components to subscribe to only specific changes in state, those in which it is interested.

In our example project, we've created a simple feature to perform multiplication and division. It provides the simple ability to multiply two numbers and return the product of those them. To accomplish this we provide the actions, the reducer and the effects to perform this operation. And to hide the details, we provide an adaptor that can be injected into any component to allow it to either initiate this behavior, to receive updates when such behavior concerns, or to do both.

The Adaptor Details

Our adaptor code is very simple:

@Injectable()
export class MultiplicationAdaptor {
private _first$ = new BehaviorSubject<number>(0);
private _second$ = new BehaviorSubject<number>(0);
private _product$ = new BehaviorSubject<number>(0);
private _showProduct$ = new BehaviorSubject<boolean>(false);

constructor(private store: Store<AppState>) {
    this.store
      .select(multiplierFeatureKey)
      .pipe(filter(state => !!state))
      .subscribe((state: MultiplicationState) => {
        console.log('*** state:', state);
        if (this._first$.getValue() !== state.first) {
          this._first$.next(state.first);
        }
        if (this._second$.getValue() !== state.second) {
          this._second$.next(state.second);
        }
        if (this._product$.getValue() !== state.product) {
          this._product$.next(state.product);
        }
        if (this._showProduct$.getValue() !== state.showProduct) {
          this._showProduct$.next(state.showProduct);
        }
      });
}

get first$(): Observable<number> {
    return this._first$.asObservable();
}

get second$(): Observable<number> {
    return this._second$.asObservable();
}

get product$(): Observable<number> {
    return this._product$.asObservable();
}

get showProduct$(): Observable<boolean> {
    return this._showProduct$.asObservable();
}

evaluate(first: number, second: number, online: boolean): void {
    this.store.dispatch(
      new MultiplierEvaluate({ first: first, second: second, online: online })
    );
}
}

As you can see, the adaptor is very simple. When created it is give a reference to the NgRx store and subscribes itself to state changes, and then updates a set of BehaviorSubject instance variables based on changes to the state.

A key piece of efficiency here is in how the adaptor updates those subjects each time the state changes: it only updates those that have changed since the last update. So, for example, if the first value wasn't changed by the user, then no update is published when the next state change occurs.

This adaptor is then injected into any component that is interested in receiving updates.

In our example application, AppComponent is the type that subscribes only to notifications to show the product and the values involved, while the MultiplicationComponent is the type that initiates the process based on user interactions.

Initiating Actions

To start the process, the user enters the first and second values into the form and clicks the Evaluate button. This results in the following call to the adaptor:

this.multiplicationAdaptor.evaluate(
this.multiplicationForm.controls.first.value,
this.multiplicationForm.controls.second.value
);

This passed the two values to the adaptor, which then translates that into NgRx action that is dispatched for processing. Below is the code from the adaptor:

evaluate(first: number, second: number): void {
this.store.dispatch(
new MultiplierEvaluate({ first: first, second: second })
);
}

With this we have decoupled our component from how the action is performed.

Observing State Changes

When the state changes, there are four things potentially published to observers: changes to the first and second values, changes to the product, and changes to the flag to show or hide the product.

Our application component is provide an instance of our adaptor (code not shown for brevity). In its Typescript code the component subscribes to updates to the show product flag and then sets its own local instance variable based on changes to the state:

ngOnInit(): void {
this.multiplicationAdaptor.showProduct$.subscribe(
show => (this.showProduct = show)
);
}

This flag toggles showing or hiding the multiplication output as we see below:

<div *ngIf='showProduct'>
  <h2>Multiplication Output</h2>
  The product of {{multiplicationAdaptor.first$|async}}

             and {{multiplicationAdaptor.second$|async}}

              is {{multiplicationAdaptor.product$|async}}.
</div>

A key piece to take note of in the HTML is how the values and the product are updated in the HTML. Rather than storing these values as instance variables on the component, the adaptor is accessed directly and, since it's an Observable, is filtered through Angular's AsynPipe. The further reduces the amount of code needed to translate state changes to updates for the user.

So, What Are The Benefits?

As you can see from this simple example, the benefits are a separation of concerns between the various components in the application and the processing of state changes, and of publishing those changes atomically to components that are interested in specific changes to the state.

Source Code

You can view the source code for this project here.

As with any other code, if you find any errors of have an update to share, please send them over and I'll include them.

Fedora VM Flickering? Here's A Fix!

noreply@blogger.com (Darryl L. Pierce) — Tue, 14 Nov 2017 20:41:00 +0000

Today I installed VirtualBox on my MacBook Pro so that I could run a virtual instance of Fedora 27. After the install finished, though, I found that the guest screen was repeatedly flickering. Not sure what the problem was, I started googling and found a forum that pointed me to Wayland as the culprit.

I logged out of Gnome, logged back in but first selected the settings gear and told GDM I wanted "Gnome on Xorg". Once I was logged in the flicker was gone.

I'm not entirely sure what the problem is, but at least at this point it's working.

Installing NVM And Node.js To Your Home Directory

noreply@blogger.com (Darryl L. Pierce) — Wed, 15 Jul 2015 14:11:00 +0000

On Fedora I've found that installing node.js and npm to be less than useful for my needs; i.e., while they install and work, they want to put things into the system directories and not my home directories. And, like with Ruby on Rails, you get locked into whatever is the latest version packaged for Fedora itself, which isn't always what you'd want.

What would be nice is to have something akin to RVM for Ruby, that lets you install the specific version you want regardless of what's packages for your release.

Enter NVM, the Node Version Manager. The name is even reminiscent of RVM! :D

To install this on my Fedora system, I first downloaded the nvm release script and executed it using:

$ wget -qO- https://raw.githubusercontent.com/creationix/nvm/v0.12.1/install.sh | bash

and then sourced my .bash_profile, which was updated to include NVM.

$ . ~/.bash_profile

I then checked to see what the latest version of node.js was to download and install

$ nvm current
v0.12.7

so I could be sure to install the latest version, which I did:

$ nvm install v0.12.7
######################################################################## 100.0%

Then, to use it, you type:

$ nvm use v0.12.7

and you should now see node in your path:

$ which node
~/.nvm/v0.12.7/bin/node

Converting VMWare Disk Images For Use With QEMU

noreply@blogger.com (Darryl L. Pierce) — Wed, 01 Jul 2015 21:49:00 +0000

At my current job we have a VM that was created by someone using VMware which hosts a scaled down version of our runtime environment. Being the new guy, and someone who's way more comfortable with Fedora Linux than Windows, I wanted to take the VM and run it on my favorite OS.

But I couldn't just copy the image over since the 60G disk was split up into 31 separate VMDK files, which cried out to be converted to a format usable by Linux.

So here's what I did:

$ for vmdk in *.vmdk; do qemu-convert -f $vmdk -O raw $(basename -s .vmdk $vmdk).img; done
$ cat *.img >> runtime_environment_vm.img

When it was all done I had a bootable disk. I created a new VM using that disk and was off to work in no time!

More Git Commit Recovery With RefLog

noreply@blogger.com (Darryl L. Pierce) — Wed, 03 Jun 2015 12:55:00 +0000

Yesterday I blogged about how I lost and then recovered a few commits in a small project I'm working on using git's cherry-pick command. Till Maas pionted out on G+ that you can get a list of the commits in your git repo with "git reflog".

The reflog command (for reference log in case the contraction was lost in you) lets you look back into the repository history beyond what makes up its current state. In our case, it can show past commit hashes so we can find and recover a commit. This would have come in handy had I not had the output of a git log in my terminal yesterday.

So, for example, I could look back through the history of my project to find all of my previous commits with:

$ git reflog show | grep commit
b3c1cf2 HEAD@{0}: commit (amend): Created the initial application shell.
1fc7d5a HEAD@{1}: commit (amend): Created the initial application shell.
f8df984 HEAD@{2}: commit (amend): Created the initial application shell.
801787d HEAD@{9}: commit (amend): fixup! Created the initial application shell.
c23dde8 HEAD@{10}: commit (amend): Added a Glade described main window.
d16b829 HEAD@{18}: commit (amend): Got a basic running application.
c49a3cb HEAD@{19}: commit: Got a basic running application.
f43fe07 HEAD@{25}: commit (amend): Added a Glade described main window.
f02d3bd HEAD@{26}: commit (amend): Added a Glade described main window.
92a16aa HEAD@{30}: commit (amend): fixup! Created the initial application shell.
4c8b148 HEAD@{31}: commit: fixup! Created the initial application shell.
5db5426 HEAD@{32}: commit (amend): Added a Glade described main window.
11a6b02 HEAD@{33}: commit (amend): Added a Glade described main window.
df9f92e HEAD@{34}: commit (amend): Added a Glade described main window.
3deafab HEAD@{35}: commit: Added a Glade described main window.
6330fe5 HEAD@{36}: commit (amend): Created the initial application shell.
a5eda9c HEAD@{37}: commit (amend): Created the initial application shell.
fcb58eb HEAD@{38}: commit (amend): Created the initial application shell.
2a0d994 HEAD@{39}: commit (amend): Created the initial application shell.
32b8ea8 HEAD@{40}: commit (amend): Created the initial application shell.
165ae57 HEAD@{41}: commit (amend): Created the initial application shell.
33f9885 HEAD@{42}: commit: Created the initial application shell.
5ea907a HEAD@{43}: commit: Created an initial to-do list of tasks for the project.
40a2f7a HEAD@{44}: commit (amend): Updated the README file with a little more details.
7d32cb2 HEAD@{45}: commit (amend): Updated the README file with a little more details.
53984e2 HEAD@{46}: commit (amend): Updated the README file with a little more details.
360ea5c HEAD@{47}: commit (amend): Updated the README file with a little more details.

And from this list I would have been able to find the commit(s) I wanted to recover using git show and then cherry-picked the appropriate one once found.

Thanks Till!

Recovering A Lost Commit With Git

noreply@blogger.com (Darryl L. Pierce) — Tue, 02 Jun 2015 18:14:00 +0000

Ever have one of those days where you make a bad decision?

No, I mean with writing code.

You do?

How about with source control? Things like deleting a commit on your work branch and then realizing you didn't mean to delete it?

Well, guess what? You're in luck! Git doesn't throw away your commits! And if, like me, you've accidentally.....okay, INTENTIONALLY deleted some work and then realized you want to recover it, you can!

A little background: I'm playing around with a tool to let me create and post a series of entries on the blog for my comic book podcast (The Comic Book Update). What I do now is manually schedule hourly posts of comic previews when the publishers send them to me. Which results in about two hours throughout the week (usually while drinking coffee and watching the news) of creating 60 posts (10 posts per day) and setting the scheduled time.

Tedious, I know. So I want to create a tool to do this.

Long story short, I started playing with a Ruby solution, a Python and a Java solution. But after deleting Ruby, I realized I in fact DO want to use it. And it was the one I had explored the most, but dammit I already deleted it!

Except, in my terminal buffer, I could still get to the commit hashes for the Ruby version!

So what I did was checkout a clean branch in my project repo. I then scrolled up and, one by one, did a git cherry pick of each of those hashes.

Voila! Commits were recovered!

The reason why is that, even when you delete a commit with "git reset --hard HEAD~1" or doing an interactive rebase and deleting commits from the list to be included, git does NOT actually throw the commit away. Instead it leaves it in the set of objects in your .git directory until such a time as you do garbage collection.

If you go into a repo and peek in the .git/objects directory you'll see a series of directories name 00, 01, ..., fe and ff (or some subset of them). Each of those is composed of multiple files, each representing a different commit. The parent directory is from the first two characters of the commit hash, and the filename is from the remainder of the hash. So if your hash id was f43fe07d9df08fdb6440c562639eb4ad4ce4c49e then you'll find that specific commit itself in .git/objects/f4/3fe07d9df08fdb6440c562639eb4ad4ce4c49e.

Such a nice turn of luck not having to rewrite that initial bit of code....thank you git!

Finding That Sweet Spot: Focus On Guake

noreply@blogger.com (Darryl L. Pierce) — Mon, 01 Jun 2015 13:19:00 +0000

One of the things I do quite often is go to a terminal, do some short command or two, then close the terminal. I do this away from my coding terminal as I don't want to contaminate bash history with those commands, mainly because I do a lot of repetitive things [1].

The application I use for such things is Guake, a great little popup terminal application that gives me exactly what I need: a simple terminal that I can show and hide without having to launch a new app. It's available on pretty much all Linux distros, so I don't think I need to tell you how to get it on your system.

The way I have Guake configured is to popup up as a small window (50% width, 50% height) at the center bottom of my current display (on my two-monitor desktop it follows the mouse pointer).

I like to have my desktop be visually appealing since I spend so much time in front of it, so I've played with various colors, layouts, etc. to get things just right. And for me, what I have now works well.

Placement shows the terminal the currently active desktop (the one where my mouse is at the time), and it pops up on top and stays on top of any other application. I have the transparency of the window set to about 15% or so to allow me to see through the window: this way I can read something on my browser or editor, for example, without having to close and re-open Guake.

To open Guake, I have F12 as my hotkey, with F11 to make it full screen. These are the default and they make perfect sense to me. Though, on my keyboards when I'm docked, F12 and Print Screen are close enough together that I will hit the latter at least once per day by mistake. So every weekend it seems I'm deleting a half dozen screen shots.... :D

The color scheme I chose is called "Hipster Green" (yeah, I hate that name too). For me I find the monochrome-like colors more visually appealing, not to mention less harsh on the eyes if I'm on my laptop in a dimly lit room [2]. I use auto-colors in ls and the monochrome color scheme fits well with it.

The option I go back and forth on is showing the tab bar. On the one hand I like to be able to quickly jump to a tab I want if it's open. But on the other hand I don't normally have more than two or three open at a time. So I hate sacrificing even that small bit of real estate. So it depends on how I'm feeling at any point whether it's enabled or not.

To open URLs that appear in the window, I've checked the Enable Quick Open when Ctrl+clicking on a filename in the terminal option (verbose, right?) on the Quick Open tab.

All in all, Guake is a great, useful tool for me to perform quick tasks from a command line without having to either pollute my primary command history with trivial little things. All in a tool that is easily launched, used, and dismissed quickly.

[1] - I will, for example, have the following three commands in my coding terminal's history:

$ git clean -xfd && cmake all
$ [run some test script, example app or other]

My main workflow in those cases it to build the world, run whatever I'm working on, then scroll through the output and fix things in my editor. Then I go back to the coding terminal and hit Up Up Enter, wait a second, then Up Up Enter again.

[2] - I LOVE to write code during a rain storm. Some of my favorite times have been to sit on the couch in my office at home while it's pouring rain out and work on code to the soothing sounds of rainfall.

Upgrading Fedora From F21 To F22 With FedUp

noreply@blogger.com (Darryl L. Pierce) — Fri, 29 May 2015 18:33:00 +0000

In case you missed the announcement, Fedora 22 was released on Tuesday, 26 May. You can download it here if you want to install a fresh copy.

Or, if you're like me, you can upgrade your system in place using dnf and fedup. Here's a simple, step-by-step guide to upgrading your system.

Step 1: Upgrade Your F21 System

This goes without saying, but I'll say it anyway: make sure your system is up to date with F21. This will ensure an easier upgrade.

Using Yum To Do A Distribution Synchronization

Step 2: Install FedUp

FedUp is the tool that does the heavy lifting for the upgrade. What it does it download the packages needed to upgrade your system from its current state to the released packages in Fedora 22.

Installing The FedUp Package

Step 3: Use FedUp To Download The Upgrade Packages

Now comes the first long task: downloading the upgrade packages. Depending on how much you have installed on your system, and the speed of your internet link, this could take a wee bit of time.

FedUp has a few options for how it retrieves the packages for the upgrade. You can download the ISO install image and use it as a source, you can point it to a mount point on a shared filesystem (a great way to upgrade multiple systems would be to download the upgrade packages to an NFS drive and mount it from the various machines) to retrieve them, or you can point it to the network and tell it download the packages from a configured repository. We'll be using this last option.

You'll also tell fedup to what version you want to upgrade your system. In this case, since we're going to Fedora 22, we'll tell it that with:

$ fedup --network 22

Running FedUp Over The Network

After this finishes, you have the option of aborting the upgrade process with:

$ fedup --resetbootloader

since FedUp will add a new entry to Grub's menu. But who's going to do that? We're here to upgrade! So now, reboot your system.

Step 4: FedUp Does The Upgrade

After rebooting your system, you'll see a new entry in Grub for the upgrade. You can still bypass the upgrade and choose one of your prior kernels. Of, by default, the system will select the upgrade path.

The FedUp Grub Menu Option

Now is the time to go have a cuppa, a pint or whatever you do to pass the time. It's going to be a while as the system is upgraded.

Step 5: Here's Your Fedora 22 System...Enjoy!

Once the install has finished, it will remove the upgrade option from Grub's menu and reboot your machine.

After The Reboot, No More Upgrade Option

You have now have a fully up-to-date and ready to run Fedora 22 system!

Ruby Messaging Part 1: Know The Players, Know The Game

noreply@blogger.com (Darryl L. Pierce) — Wed, 18 Feb 2015 15:27:00 +0000

Hey, all. Here's a new series of blog posts I've been thinking about for a few weeks now. It's a series where I'm hoping to introduce you to a bit of work I've been doing lately on the Ruby messaging front with Qpid Proton. Specifically, I've been working on a low-level set of APIs dubbed the "engine APIs". They are a close analog to elements in the AMQP protocol specification, so a knowledge of one will help in understanding the other.

In this first post I'm going to introduce you to the main players in the game and how they each represent aspects of the AMQP messaging specification. Then I'll share a very small example application that accepts a connection from a remote container, but does nothing else for now. This application we can grow over the process of these posts until we have fully functional application.

The Logical Components

Working from the outside in, we have the following pieces:

A container is either a producer, a consumer, both a producer and a consumer, or a queue. As their names imply, producers and consumers either produce (send) messages or else consume (receiver) messages, or both, as is the case with most messaging containers.

A container that primarily produces/consumers messages is going to be an application that uses messaging as a means of coordinating its efforts with other applications. An example, which I'll develop over the course of these blog posts, is a traffic light system which is designed to work with the local municipality's emergency needs.

A container that acts as a queue would be a broker, communications bridge or similar application. It's not the endpoint for the bulk of the messages it receives, but is really a conduit through which messages flow on their way to their true endpoint; i.e., it stores and then forwards messages. Examples would include the Qpid C++ broker and the Qpid Dispatch router.

Containers create connections to, or accept from, other containers. The connection is how data actually flows in between the two containers and is broken down into constituent pieces, like the layers of an onion. But the details of that flow are outside of the scope of this series of posts.

Within connections are sessions. A session will have a pair of channels for sending and receiving data.

Connections and session are thought of as endpoints which hold incoming messages and which hold the last known state information for outgoing messages.

A channel is a unidirectional (one way) means of sending messages. The reason why a session contains a pair of channels is to allow for bidirectional (two way) communcation.

The terminus maintains the state information for incoming and outgoing messages that flow over the link. A channel will have a source and a target terminus.

The link is the where the actual protocol work is done, transmitting the message from source to target. It ties together the termini of a channel.

So, to summarize:

A container is an application that produces, consumes or queues messages.
A connection is how two containers communicate with each other.
A connection has one or more sessions, which pair up unidirectional channels to allow bidrectional communication.
A channel sends data from one endpoint to the other over a link unidirectionally.
A channel has a terminus which maintains the state information on each end of its link.

Translating To Ruby Classes

So now that we know the big picture pieces from the specification, I'll translate that knowledge to the Proton Ruby engine work I've been done.

There is no analog (at this time) in the library for a container.

The Qpid::Proton::Connection class represents the connection between containers. With it you can start and stop working with a remote container, create new sessions, retrieve the next session which has pending work and also the next link with pending work to process. You can also access the transport engine, which is itself the topic for another post.

The Qpid::Proton::Session class is the session analog. With it you can start and stop sessions with the remote container, create endpoints to send and receive messages, peek at how many incoming and outgoing bytes there are as well as access the parent connection.

The Qpid::Proton::Sender and Qpid::Proton::Receiver classes are used for sending and receiving instances of Qpid::Proton::Message, respectively.

Additional Classes

In the Ruby library there are additional classes that work with the specification analogs to tie things together: the Transport and the Collector.

The Qpid::Proton::Transport class is the protocol engine. It processes incoming and outgoing bytes for a connection, and publishes events as that connection's state evolves over time.

The Qpid::Proton::Collector class is a FIFI queue which holds the events fired by the transport. It can be queried by the container to find the oldest event.

An Example Application: The Traffic Light Manager

Following is a simple Ruby application that accepts incoming connections and starts an AMQP dialog follows. It accepts a TCP connection, creates a connection and related objects and then begins looking at events to process.

Bear in mind that this application is by no means the best example of how to write such an application, but is only used as a means of demonstrating how the pieces we're shown here fit together. A more details example will be developed in follow up posts.

require 'qpid_proton'
require 'socket'

server = TCPServer.new(5672) # accept connections on the default AMQP port

# start an infinite loop
loop do
# spawn a new thread for each incoming client
Thread.new(server.accept) do |client_socket|
# Create a connection object, a collector for any
# events, and a transport to process the data
# flowing over the wire.
conn = Qpid::Proton::Connection.new
collector = Qpid::Proton::Collector.new
conn.collect(collector)
transport = Qpid::Proton::Transport.new

# details of moving data between the client socket
# and the transport are excluded here
#
# instead, we'll just jump right to processing events

# get the next event
event = collector.peek

unless event.nil?
# do something here, a detail for a later post

# remove the event we've processed and get the next
collector.pop
event = collector.peek
end
end
end

Get Your Battery's Serial Number From A Terminal

noreply@blogger.com (Darryl L. Pierce) — Fri, 29 Aug 2014 13:56:00 +0000

For my work laptop (Lenovo T530) I've been seeing the battery life quickly declining in the past few weeks. I've been meaning to check the warranty on it but, every time I think about it, I'm ON the laptop at work and don't want to have to undock it to get the serial number.

I figured I'd just get it from the command line somehow. And that's what I found using the upower command.

O_o (1) [J:0/1113] mcpierce@mcpierce-laptop:acpi $ upower -h
Usage:
upower [OPTION...] UPower tool

Help Options:
-h, --help Show help options

Application Options:
-e, --enumerate Enumerate objects paths for devices
-d, --dump Dump all parameters for all objects
-w, --wakeups Get the wakeup data
-m, --monitor Monitor activity from the power daemon
--monitor-detail Monitor with detail
-i, --show-info Show information about object path
-v, --version Print version of client and daemon

The first thing to do is to enumerate the list of power devices available using the -e or --enumerate command line option:

^_^ [J:0/1115] mcpierce@mcpierce-laptop:acpi $ upower --enumerate
/org/freedesktop/UPower/devices/line_power_AC
/org/freedesktop/UPower/devices/battery_BAT0

Here we can see two devices relating to power: battery_BAT0 and line_power_AC. And I'm going to go out on a limb here and say that battery_BAT0 is the one we want to interrogate.

So now we ask it for information using the -i or --show-info command line option:

^_^ [J:0/1116] mcpierce@mcpierce-laptop:acpi $ upower --show-info /org/freedesktop/UPower/devices/battery_BAT0
native-path: BAT0
vendor: LGC
model: 45N1011
serial: XXXXX
power supply: yes
updated: Fri 29 Aug 2014 09:20:05 AM EDT (1932 seconds ago)
has history: yes
has statistics: yes
battery
present: yes
rechargeable: yes
state: fully-charged
energy: 72.25 Wh
energy-empty: 0 Wh
energy-full: 72.25 Wh
energy-full-design: 93.6 Wh
energy-rate: 2.82857 W
voltage: 12.854 V
percentage: 100%
capacity: 77.1902%
technology: lithium-ion

As we can see in the output the serial number for the laptop batter is listed, along with the vendor tag and model number.

Happy 30th Birthday, GNU!

noreply@blogger.com (Darryl L. Pierce) — Fri, 27 Sep 2013 14:13:00 +0000

On 27 September 1983 Richard M. Stallman posted the following message to a newsgroup:

From CSvax:pur-ee:inuxc!ixn5c!ihnp4!houxm!mhuxi!eagle!mit-vax!mit-eddie!RMS@MIT-OZ
From: RMS%MIT-OZ@mit-eddie
Newsgroups: net.unix-wizards,net.usoft
Subject: new Unix implementation
Date: Tue, 27-Sep-83 12:35:59 EST
Organization: MIT AI Lab, Cambridge, MA

Free Unix!

Starting this Thanksgiving I am going to write a complete
Unix-compatible software system called GNU (for Gnu's Not Unix), and
give it away free(1) to everyone who can use it.
Contributions of time, money, programs and equipment are greatly
needed.

To begin with, GNU will be a kernel plus all the utilities needed to
write and run C programs: editor, shell, C compiler, linker,
assembler, and a few other things. After this we will add a text
formatter, a YACC, an Empire game, a spreadsheet, and hundreds of
other things. We hope to supply, eventually, everything useful that
normally comes with a Unix system, and anything else useful, including
on-line and hardcopy documentation.

GNU will be able to run Unix programs, but will not be identical
to Unix. We will make all improvements that are convenient, based
on our experience with other operating systems. In particular,
we plan to have longer filenames, file version numbers, a crashproof
file system, filename completion perhaps, terminal-independent
display support, and eventually a Lisp-based window system through
which several Lisp programs and ordinary Unix programs can share a screen.
Both C and Lisp will be available as system programming languages.
We will have network software based on MIT's chaosnet protocol,
far superior to UUCP. We may also have something compatible
with UUCP.

Who Am I?

I am Richard Stallman, inventor of the original much-imitated EMACS
editor, now at the Artificial Intelligence Lab at MIT. I have worked
extensively on compilers, editors, debuggers, command interpreters, the
Incompatible Timesharing System and the Lisp Machine operating system.
I pioneered terminal-independent display support in ITS. In addition I
have implemented one crashproof file system and two window systems for
Lisp machines.

Why I Must Write GNU

I consider that the golden rule requires that if I like a program I
must share it with other people who like it. I cannot in good
conscience sign a nondisclosure agreement or a software license
agreement.

So that I can continue to use computers without violating my principles,
I have decided to put together a sufficient body of free software so that
I will be able to get along without any software that is not free.

How You Can Contribute

I am asking computer manufacturers for donations of machines and money.
I'm asking individuals for donations of programs and work.

One computer manufacturer has already offered to provide a machine. But
we could use more. One consequence you can expect if you donate
machines is that GNU will run on them at an early date. The machine had
better be able to operate in a residential area, and not require
sophisticated cooling or power.

Individual programmers can contribute by writing a compatible duplicate
of some Unix utility and giving it to me. For most projects, such
part-time distributed work would be very hard to coordinate; the
independently-written parts would not work together. But for the
particular task of replacing Unix, this problem is absent. Most
interface specifications are fixed by Unix compatibility. If each
contribution works with the rest of Unix, it will probably work
with the rest of GNU.

If I get donations of money, I may be able to hire a few people full or
part time. The salary won't be high, but I'm looking for people for
whom knowing they are helping humanity is as important as money. I view
this as a way of enabling dedicated people to devote their full energies to
working on GNU by sparing them the need to make a living in another way.

For more information, contact me.
Arpanet mail:
RMS@MIT-MC.ARPA

Usenet:
...!mit-eddie!RMS@OZ
...!mit-vax!RMS@OZ

US Snail:
Richard Stallman
166 Prospect St
Cambridge, MA 02139

Git/Subversion Error: "Index mismatch: [hash] != [hash]"

noreply@blogger.com (Darryl L. Pierce) — Tue, 10 Sep 2013 12:29:00 +0000

The Problem

Our source code is stored in a Subversion repository (it's an Apache project) and I use Git to clone that repo for work. This morning I attempted to update my local repo when the following happened:

^_^ [J:0/1003] mcpierce@mcpierce-laptop:Qpid (upstream) $ git svn rebase
Index mismatch: e5893616e68dba2bd8a730609d872f19517e0536 != 93c1bfda2ff4e72a1ae1fbc8374d42ebe107e1f5
rereading 695961e1cc7749916959f1f74db659e90e0d2dcc
 M qpid/cpp/src/qpid/broker/SessionState.h
 M qpid/cpp/src/qpid/broker/SemanticState.cpp
 M qpid/cpp/src/qpid/broker/SessionState.cpp
Author: pmoravec not defined in .git/authors.txt file

The user "pmoravec" was recently added as a committer to the project and his first commit apparently threw my git clone of the subversion repository off.

The Solution

For me it was a simple solution. I simply had to pull down the updated authors.txt file from Apache that included pmoravec and replace the one in my git repo:

^_^ [J:0/1029] mcpierce@mcpierce-laptop:Qpid (master) $ wget http://git.apache.org/authors.txt

Done and one, now I'm back to work.

Puppet: Defining A System, Adding A Package And Launching A Service

noreply@blogger.com (Darryl L. Pierce) — Thu, 22 Aug 2013 13:44:00 +0000

Previously I wrote a simple blog post about setting up a Puppet master and agent. In this post I'm going to write about how to add a simple service to your puppet master that will be installed (if necessary) and started (if necessary) on systems.

Step 1: Define the system on your Puppet master

Before your Puppet master can do its work, it needs to first know what needs to be done and to whom.

In your /etc/puppet/manifests directory you'll want to create two files with the following content (remember: in my case the Puppet master's name is earth and the Puppet client's name is halo):

site.pp

import 'nodes.pp'

filebucket { main: server => "earth.gateway.2wire.net" }

File { backup => main }
Exec { path => "/usr/bin:/usr/sbin:/bin:/sbin" }

nodes.pp

# nodes.pp

node default {
include ntp
}

node 'halo.gateway.2wire.net' inherits default {

}

In this example the default system definition will install the sudo module. The definition for a server will inherit that definition and add to it the ntp module. And finally the definition for halo inherits the server definition and adds to it the bip module.

In later posts I'll expand on the above to do more involved server definitions, specifically add modules that include files. But let's not get ahead of ourselves.

Step 3: Add the module definition

Before Puppet can do anything on the client it has to have more details on, in this case, the ntp module.

To do that we first create the file /etc/puppet/modules/tests/init.pp with the following content:

class { 'ntp': }

Next we'll create the file /etc/puppet/modules/ntp/manifests/init.pp with the following content:

class ntp {

    package { ntp: ensure => installed }

    file { "/etc/ntp.conf":
      owner => root,
      group => root,
mode => 640,
      require => Package["ntp"],
}

service { 'ntp':
name => 'ntpd',
      ensure => running,
      enable => true,
subscribe => File['/etc/ntp.conf'],
}

}

In the configuration we ensure the package is installed, that, if the file /etc/ntp.conf exists, the configuration is owned by user root and group root, that it has the proper file modes, and that if it doesn't exist the package named ntp is installed to provide it.

The service stanza adds to the above a check for the actual service itself. If Puppet doesn't see a process named "ntpd" then it knows that the service isn't up and will launch it for you.

Conclusion

That's it! If you then launch the puppet agent on your client machine, you should see it apply the above configuration by installed the package named ntp.

A Simple Puppet 3.1 Setup

noreply@blogger.com (Darryl L. Pierce) — Mon, 19 Aug 2013 01:25:00 +0000

Recently I got the notion of setting up a puppetized configuration system for my computers at home. I have two machines:

earth - a Linux desktop, which will be the puppet client
halo - a Linux server, which will be the puppet server as well as a client

My biggest frustration, though, was find a simple tutorial that would help me get Puppet up and running, the two machines talking, and a configuration pushing down onto the client.

So after pulling from a few separate sources, here's what I found works. In a future post I'll write about how, after more frustration, I was able to get configurations pushing down onto the systems and how I setup version control on the puppet configurations themselves.

Step 1: Install Puppet (Fedora 19)

Not the hardest part, but you do need to be aware of what packages are out there. The two packages are puppet and puppet-server. The former is what you need on any system that will act as a client or agent, the latter on any system that will be offering up puppetized data.

So, obviously, I installed puppet on halo, and puppet and puppet-server on earth.

Step 2: Configuring The Puppet Master

This is the first part that gave me headaches. Since I don't want to deal with external certificates, I just wanted something that would work for me in my private network.

What I did was to configure earth to be it's own certificate authority with the following in /etc/puppet/puppet.conf:

[main]
    logdir = /var/log/puppet
    rundir = /var/run/puppet
    ssldir = $vardir/ssl

    # self-signing certificates
    server = earth.gateway.2wire.net
    certname = earth.gateway.2wire.net
[master]
    reports = store, http
    modulepath=/etc/puppet/modules:/usr/share/puppet/modules

[agent]
    classfile = $vardir/classes.txt
    localconfig = $vardir/localconfig

Step 3: Exchanging SSL Certificates With The Agent

Here is where there was a decided lack of examples online. And the Puppet website didn't help at all, especially with recovering things after a failure occurred.

The steps to follow are:

unless you have your own DNS, add the fully qualified hostnames of each machine in the other's /etc/hosts file; i.e., for me I had to put earth.gateway.2wire.net in halo's file, and halo.gateway.2wire.net in earth's, then
open two terminals on your puppet master (in my case, on earth) and one on your puppet agent (in my case, on halo), then
start up in one puppet master terminal a master using the command line:

puppet master --no-daemonize --verbose

on the puppet agent terminal start an agent using the command line:

puppet agent -t --no-daemonize --verbose

you'll see some messages about exchanging the SSL credentials and then a note that no certificate is waiting, at which point in the other puppet master terminal window you'll do:

puppet cert sign halo.gateway.2wire.net

At this point your machines will have shared SSL credentials and will be able to talk to each other.

Step 4: How To Recover If Something Goes Wrong

If you start getting messages about the keys being wrong on the agent side, the easiest thing to do is to delete the /var/lib/puppet/ssl/ directories on BOTH machines. This way you no longer have any data about the other system and can start over with a clean slate.

Grouping Channels In Weechat By Network

noreply@blogger.com (Darryl L. Pierce) — Sun, 04 Aug 2013 14:39:00 +0000

One of the things that's kept me from switching from Xchat to Weechat for IRC was that I couldn't keep my channels grouped together by network. Where I work we have internal IRC channels with the same name as public IRC channels, and it was confusing to look at the window and figure out which was internal or not.

Fortunately, I found a way to change that in Weechat and so have switched over to it exclusively. Here's how:

Install the buffers.pl plugin.

The buffers plugin lets you configure how the various buffers are displayed.

/script install buffers.pl

Tell buffers.pl to show the IRC network name.

By default buffers.pl only shows the channel name (#name). To group channels together, you need to enable showing the fullly qualified channel name (network#name):

/set buffers.look.short_names off

Sort channels by name and not numbers.

This groups the channels together by their server name. Otherwise they're grouped by the order in which they were opened. So if you open a channel in Freenode, say, after opening one in OFTC then the channel in Freenode will fall after OFTC and not get put with the other Freenode channels.

/set buffers.look.sort name

That's it! Now your channels are grouped together by network.

Fedora 19: Nouveau Drivers Are Fixed!

noreply@blogger.com (Darryl L. Pierce) — Tue, 09 Jul 2013 13:04:00 +0000

At work a few months ago I got a new laptop: a Lenovo T530 with the Optimus Technology display chipset:

For more taxing multimedia and gaming use, NVIDIA's line of NVS with Optimus graphics cards provide the graphical processing boost you need. Optimus technology automatically configures your system to provide for the most optimal experience with your games or applications while also maintaining battery life.

The problem that I hit was that the Nouveau drivers would NOT work nicely with this video setup. If I disabled the nVidia hardware and run only the Intel video chipset things worked beautifully, but I could not use my docking station since it doesn't support external displays. If I enabled the nVidia hardware only then I could drive my external monitors but couldn't go into standby mode, couldn't dock and then undock, and inevitably the display would get borked (BZ#948079).

To deal with the problem, I had no choice but to start using the closed-source nVidia drivers. They're freely licensed, but being closed source just goes against the spirit of what I support. And it also has the annoying habit of requiring me to run the nVidia configuration tool when I dock my laptop in order to enable the external monitors rather than just switching to them automatically, which is what the nouveau drivers do.

So when I upgraded my laptop with Fedora 19 (Schroedinger's Cat), I was happy to find that the bug had, at some point, been quietly fixed!

Omniscience Vs. Free Will: A VERY Old Web Page I Wrote

noreply@blogger.com (Darryl L. Pierce) — Wed, 05 Jun 2013 15:56:00 +0000

Years ago I wrote the following about the logical inconsistency between free will and omniscience. I hadn't thought about or read the page in a long time, but it came to mind today when someone sent an email asking to translate the website I had back in the early 2000s.

The Basic Premise

The concepts of omniscience and free will and mutually exclusive. If there exists omniscience, then no being is able to make choices other than those known by the omniscient being. If free will exists, then there can be no such thing as omniscience.

What Is Omniscience?

Omniscience: having infinite awareness, understanding and insightpossessed of universal or complete knowledge

A being with omniscience is one that has complete knowledge of the universe. There can be no knowledge that this being does not possess. Nothing for it to learn since learning would require a form of limited knowledge where information is not contained in one state and then is contained in another state.

What Is Free Will?

Free Will: freedom of humans to make choices that are not determined by prior causes or divine intervention

In order for a being to have free will, it must be able to choose any possible action when a decision action is presented. Any choice that is possible must be allowed without external intervention or influence.

So, What's The Problem?

With omniscience, all knowledge is known, including the choice made by each being at every stage. It is not possible for a being to make a choice other than what is already known via omniscience, thereby precluding any chance for free will. A being cannot make any choice that would contradict omniscience, since omniscience by nature requires that all choices be predetermined.

So what?

What if the omniscient being is outside of our space-time?

Well, whether that being is confined to our universe or is somehow able to exist outside of our universe, if it has omniscience with regards to our universe then it directly affects the free will of beings within out universe. The contradiction comes from our choices being decided before they are made within our flow of time.

Can't the being outside of our universe view our choices to learn them?

Sure. But, that is not omniscience: it is limited knowledge. Omniscience is, by definition, infinite knowledge. Since it is impossible to combine enough finite elements to reach infinity, a being cannot reach omniscience by learning.

An Example Of The Contradiction

I wake up and decide to have oatmeal for breakfast rather than eggs.

Have I made a choice of my own free will?

That depends. If there is a being with omniscience, then my choice to have oatmeal was dictated before the morning in question. I did not make a choice; instead, I acted out a script that only superficially looks like free will. The choice to have oatmeal was made by something other than myself and I could only follow along acting out a script and not making a choice of my own free will.

The problem is that omniscience requires 100% perfect knowledge. This leaves no room for variation. When each decision fork is reached, only one branch can be followed: the one previously decided via omniscience.

But, Don't We Have Free Will?

Apparently, yes, we do. But, that's not the issue. The contradiction does not mean that we do not have free will. Since we seem to have free will, the only way to resolve the contradiction is to admit that there cannot exist a being with omniscience.

Can Omniscience Be Learned?

No. The process of learning is based on having limited knowledge. Since omniscience is the state of having infinite knowledge, you can't accumulate knowledge until you finally have infinite knowledge. The problem is that there is no such thing as infinity minus one. How can you be one unit of knowledge away from having infinite knowledge?

Can't A Being Have Foreknowledge Instead?

Sure! But, foreknowledge is not the same as omniscience. Foreknowledge is merely the knowledge of something in advance, and is based on limited knowledge. A being can have foreknowledge without being omniscience.

You do not become omniscient by watching a movie backwards, for example. Omniscience would require a being to know the entire movie inside and out before ever actually observing the film.

Why Can't A Being Have Progressive Omniscience?

Progressive omniscience is a meaningless phrase. This would be knowledge gained, and is discussed above under the header Can Omniscience Be Learned?

Podcasting 101: Creating A Podcast Website

noreply@blogger.com (Darryl L. Pierce) — Fri, 17 May 2013 14:05:00 +0000

In this installment, I'll help you to understand how to create a single episode of your new podcast by taking you through the steps I follow. We will assume that you've already recorded, mixed and exported the audio.

First things first, though, you'll need to create a blog for your podcast. Then we will setup a Feedburner redirector for the podcast so that, should you ever need to move the podcast to a different hosting site, you won't have to force your listeners to manually change their feed location.

Creating The Podcast Blog Site (With Blogger.com)

I choose blogger.com for no other reason than I use it myself for both of my shows. Though I'm sure the steps I describe will apply to other sites later.

If you have a Google account already, you're halfway to creating your blog. If not, register for one by signing up for Gmail.

Go to blogger.com. There you will see a button in the upper-left corner that says "New Blog".

Click it.

Hopefully you've chosen a decent name for your podcast, something catching, creative and fresh. For now we won't worry about creating a podcast domain name, so in the field marked "Address" enter a unique, simplified version of your podcast's name.

Click "Create Blog!"

Now we have a way to share the episodes.

Adding Your Custom Domain

On the blog list screen, click on the blog's name, and you will see a page with options such as "Post", "Pages", "Earnings", etc. Towards the bottom of this list is "Settings".

Click it.

Under the "Publishing" heading you'll want to click "Add a custom domain". This will open an input field that will let you put in the hostname you've setup (instructions are in a future installment) for your podcast's blog site.

For example, at A Little Dead Podcast our blog's hostname is http://blog.alittledead.com. So, in this field, I have "blog.alittledead.com". What this does is tell Blogger that it should make all pages and blog posts use a URL relative to the address entered.

If you don't understand what that means, it's okay. You can trust me on this.

Now you have an address you can share with listeners to tell them where to go to find your show.

Setting Up A Feed Redirector

Feedburner is a great, useful tool for podcasters. It lets you see how many times your episodes have been downloaded, from what countries the downloads have occurred, and more.

Here, though, we're going to setup the redirector itself. But there's a lot more than Feedburner can do for you, which we will explore in another installment.

In a separate tab on your browser, go to the website: feedburner.google.com

You'll see the text "Burn a feed right now" along with an input field and a checkbox that says "I am a podcaster".

Mark the checkbox.

In the input field, enter the URL for your podcast. If you don't have a custom domain and used Blogger then this is the name of your podcast followed by .blogger.com.

So, for example, if you gave your blog the name "testcast2" in the earlier step, then here you would enter testcast2.blogger.com.

Click "Next". If you entered the right information then you should be presented with two options under the title "Identify Feed Source":

an atom feed, and
an RSS feed

You want to select the RSS feed here, and click Next. On the next screen enter the title for your podcast redirector, and also pick and address for it. For this latter entry, pick something simple, like the name of your podcast's abbreviated name on your host site. So, again, in this example, since I named the podcast "testcast2" on blogger.com, I would enter "testcast2" as the feed address.

Click Next.

On the congratulations page you'll see a feed URL at the top that looks something like this:

http://feeds.feedburner.com/testcast2

Copy this address and go back to you blog's setup page. Under the Settings->Other->Site Feed section, click Add for the "Pod Feed Redirect URL" and paste the URL into the input field shown.

Click the "Save Settings" button in the upper-right corner.

Back on the Feedburner page, click through all of the the Next buttons until you're back to the main page.

There! Now you have a podcast blog as well as an active feed. To verify the feed as working, copy the feedburner URL into your browser. If everything is setup correctly then you should see page that shows you an empty feed.

Future Installments

In a future installment, I'll show you how to configure Feedburner to do things like alter your RSS feed for iTunes, inserting elements that Apple specifically wants to have present, how to register the podcast with iTunes, how to change your feed to track statistics for episodes entries separately from non-episode entries on your blog (we post news that I want to view separately when looking at the audience breakdown).

Also how to use Project Wonderful for making the podcast's website help pay for itself while growing your audience.

Till then, have fun with your new website!

Podcasting 101: What Are The Things I Need?

noreply@blogger.com (Darryl L. Pierce) — Thu, 16 May 2013 15:50:00 +0000

The first question, and probably the most challenging one for the new podcast host, is what are the things I need to create and share my show?

What you (minimally) need is:

equipment to record and edit your episodes
a means of posting the episodes themselves online
a way of letting listeners/viewers know that the new episodes are available

Here's what I use for my shows. I'm not going to talk about video equipment since that's a whole world different when it comes to recording and editing than audio equipment. I'll talk about that in a future installment.

Recording Equipment

Software

To record episodes, you'll want something that allows you to record multiple tracks of audio.

For normal recordings I use Audacity, available here. It's free, available on Linux, Windows and the Mac, and supports all standard audio formats. It uses its own format for locally storing a project, but you can export the audio to MP3, Ogg Vorbis, WAV, etc. Though for podcasts I recommend MP3.

And during exports, you can add most ID3 meta data to the episode.

In a later installment I'll talk about how to use Audacity in more detail.

Microphone

Don't skimp on this piece, but do pick something in your budget. Remember: you get what you pay for, and buying a cheap microphone results in bad audio quality. You want something that produces a warm sound. A decent USB headset with built-in microphone (like my Microsoft Lifechat LX-3000) works great for this, and you can use it for other things such as recording interviews, which is another installment.

Other Equipment

If you want to use a standard studio microphone (which is what I do for normal episodes), you'll want to also get a USB mixer. A certain cohost of mine gave me a very nice microphone and mixer setup that matches what he uses for his segments. And I found that it provides the best audio quality to date for the show.

Posting Episodes Online

After you've produced your episode, you need to put it up online so listeners can get to it.

The cheapest way to do this is to post the episodes on archive.org. The only caveat is that you need to release your audio under some sort of free or unencumbered license. My shows are all released under Creative Commons Share-Alike Non-Commercial (CC-SA-NC) licenses. People are free to take the audio, cut it up and use bits of it, so long as it's for non-commercial results (they can't charge for the results), they have to give a reference back to us and they have to allow others to take their work and do the same.

After you've uploaded your episode to archive.org, you can then get a link directly to the MP3 file that you would put into your podcast feed. That way listeners can download the file. More on that in a later installment.

Notifying Listeners

To notify listeners that you have a new episode available, you have to create an RSS feed, which is simpler than it sounds. The first step is to create a blog, and the second is to add it to podcast aggregators like iTunes, which will also be a later installment.

Another thing to do is to setup a feed redirector, such as Feed Burner, and tell listeners to subscribe to that. Setting that up is also a later installment.

The cheapest thing is to create a blog on a free site like Blogger.

After you've uploaded your MP3 file to archive.org, you create a new blog entry on your site. In the lower-right corner where it says "Links" you copy the MP3's URL (being sure to change "https" to "http" if your URL has that) into both the "Title Link" and "Enclosure Link" fields, and setting the mime type to "audio/mp3".

Once you publish the new blog entry, anybody who is subscribed to the RSS feed for the blog will be notified that a new episode is available.

Conclusion

Setting up a podcast feed is pretty simple IF you have the right tools and services in place. With these first few steps you're now well on your way to being a podcaster.

Podcasting 101: How To Do A Podcast For Little To No Money

noreply@blogger.com (Darryl L. Pierce) — Thu, 16 May 2013 14:39:00 +0000

My two podcasts (A Little Dead Podcast and The Zombie Mob) recently joined a network of other podcasters called The 76th Street Network. And after talking with a few other podcasts, I found that not everybody is as familiar with the tools and services that are available.

So what I'm going to do is, over time, write up a series of blog entries here for how to take advantage of those free services and tools and also the little tips and tricks that I've developed over the past four years of hosting my own shows.

Keep an eye out here for ~~episodes~~ installments as they're posted.

Flock To Fedora

noreply@blogger.com (Darryl L. Pierce) — Thu, 09 May 2013 12:45:00 +0000

From the website:

For eight years, Fedora users and developers have gathered at an event named for them, the Fedora Users and Developers conference (FUDCon). But we’ve grown, and it’s time for a new approach: Flock.

Flock is a brand new conference where Fedora contributors can come together, discuss new ideas, work to make those ideas a reality, and continue to promote the core values of the Fedora community: Freedom, Friends, Features, and First.

Fedora and the people who participate in the project encompass so much more than just an interest in Linux. Flock is where you meet with other members of the Fedora community who share whatever your interest is, whether that’s the kernel or the cloud, hardware or UX design. We also want to embrace and invite the growing open hardware community so that we can learn from one another and create better things together.

The first flock will be held 09-12 August in Charleston, SC. For more, click on the link above. And if you want to present at the conference, please go here and submit your topic.

Close Windows, Open Doors

noreply@blogger.com (Darryl L. Pierce) — Thu, 02 May 2013 17:08:00 +0000

Microsoft wants to keep you locked in to Windows so that it can take your money, your personal data, and your user freedom. They don't want you to know that you have a choice of better operating systems; operating systems that respect your freedom. There are tons of free "as in freedom" software operating systems that you can download and install at no cost. And when they're improved, you can choose whether or not you want to upgrade, without a corporation breathing down your neck.

It is time to upgrade your computer, but not to Windows 8. Pledge to free your computer today!

Fedora 19: Nouveau Test Day Is The 24th

noreply@blogger.com (Darryl L. Pierce) — Tue, 23 Apr 2013 13:38:00 +0000

Having just received a new laptop at work (Lenovo Thinkpad T53), I was eager to load it with Fedora and get to work. But, unfortunately, there's a known bug with the nVidia graphics hardware and the nouveau drivers. If I suspend/resume my laptop, the display most likely comes back as unusable. Not locked up (I can still drop to a tty and do "init 3; init 5; exit" to get to workable desktop.

Definitely not a Good Thing™ since I like to have the laptop suspend when I close the lid to change locations, etc. I don't want to go through the whole shutdown and then startup process each time.

Fortunately, tomorrow is the Fedora 19 Test Day for Nouveau and nVidia graphics hardware! So I downloaded the latest F19 x86_64 LiveCD image, put it on a thumbdrive, and will be doing some testing later today and reporting back my findings.

Not the least of which is this one bug that's got me partially missing my old laptop.