Site Map - skip to main content

Hacker Public Radio

Your ideas, projects, opinions - podcasted.

New episodes Monday through Friday.



Welcome to HPR the Community Podcast Network

We started producing shows as Today with a Techie on 2005-09-19, 14 years, 6 months, 16 days ago. Our shows are produced by listeners like you and can be on any topic that "are of interest to Hackers". If you listen to HPR then please consider contributing one show a year. If you record your show now it could be released in 11 days.

Meet the team

Please help out tagging older shows !


Latest Shows


hpr3041 :: How to use GNU Autotools

How to use GNU Autotools

Hosted by klaatu on 2020-03-30 is flagged as Clean and released under a CC-BY-SA license.
Tags: autotools,build,make.
Listen in ogg, spx, or mp3 format. Series: Programming 101 | Comments (0)

I found a great article on this topic here: https://opensource.com/article/19/7/introduction-gnu-autotools, so please refer to that as show notes.

Page included by Ken, as permitted by cc-by-sa

Introduction to GNU Autotools

Have you ever downloaded the source code for a popular software project that required you to type the almost ritualistic ./configure; make && make install command sequence to build and install it? If so, you’ve used GNU Autotools. If you’ve ever looked into some of the files accompanying such a project, you’ve likely also been terrified at the apparent complexity of such a build system.

Good news! GNU Autotools is a lot simpler to set up than you think, and it’s GNU Autotools itself that generates those 1,000-line configuration files for you. Yes, you can write 20 or 30 lines of installation code and get the other 4,000 for free.

Autotools at work

If you’re a user new to Linux looking for information on how to install applications, you do not have to read this article! You’re welcome to read it if you want to research how software is built, but if you’re just installing a new application, go read my article about installing apps on Linux.

For developers, Autotools is a quick and easy way to manage and package source code so users can compile and install software. Autotools is also well-supported by major packaging formats, like DEB and RPM, so maintainers of software repositories can easily prepare a project built with Autotools.

Autotools works in stages:

  1. First, during the ./configure step, Autotools scans the host system (the computer it’s being run on) to discover the default settings. Default settings include where support libraries are located, and where new software should be placed on the system.
  2. Next, during the make step, Autotools builds the application, usually by converting human-readable source code into machine language.
  3. Finally, during the make install step, Autotools copies the files it built to the appropriate locations (as detected during the configure stage) on your computer.

This process seems simple, and it is, as long as you use Autotools.

The Autotools advantage

GNU Autotools is a big and important piece of software that most of us take for granted. Along with GCC (the GNU Compiler Collection), Autotools is the scaffolding that allows Free Software to be constructed and installed to a running system. If you’re running a POSIX system, it’s not an understatement to say that most of your operating system exists as runnable software on your computer because of these projects.

In the likely event that your pet project isn’t an operating system, you might assume that Autotools is overkill for your needs. But, despite its reputation, Autotools has lots of little features that may benefit you, even if your project is a relatively simple application or series of scripts.

Portability

First of all, Autotools comes with portability in mind. While it can’t make your project work across all POSIX platforms (that’s up to you, as the coder), Autotools can ensure that the files you’ve marked for installation get installed to the most sensible locations on a known platform. And because of Autotools, it’s trivial for a power user to customize and override any non-optimal value, according to their own system.

With Autotools, all you need to know is what files need to be installed to what general location. It takes care of everything else. No more custom install scripts that break on any untested OS.

Packaging

Autotools is also well-supported. Hand a project with Autotools over to a distro packager, whether they’re packaging an RPM, DEB, TGZ, or anything else, and their job is simple. Packaging tools know Autotools, so there’s likely to be no patching, hacking, or adjustments necessary. In many cases, incorporating an Autotools project into a pipeline can even be automated.

How to use Autotools

To use Autotools, you must first have Autotools installed. Your distribution may provide one package meant to help developers build projects, or it may provide separate packages for each component, so you may have to do some research on your platform to discover what packages you need to install.

The primary components of Autotools are:

  • automake
  • autoconf
  • make

While you likely need to install the compiler (GCC, for instance) required by your project, Autotools works just fine with scripts or binary assets that don’t need to be compiled. In fact, Autotools can be useful for such projects because it provides a make uninstall script for easy removal.

Once you have all of the components installed, it’s time to look at the structure of your project’s files.

Autotools project structure

GNU Autotools has very specific expectations, and most of them are probably familiar if you download and build source code often. First, the source code itself is expected to be in a subdirectory called src.

Your project doesn’t have to follow all of these expectations, but if you put files in non-standard locations (from the perspective of Autotools), then you’ll have to make adjustments for that in your Makefile later.

Additionally, these files are required:

  • NEWS
  • README
  • AUTHORS
  • ChangeLog

You don’t have to actively use the files, and they can be symlinks to a monolithic document (like README.md) that encompasses all of that information, but they must be present.

Autotools configuration

Create a file called configure.ac at your project’s root directory. This file is used by autoconf to create the configure shell script that users run before building. The file must contain, at the very least, the AC_INIT and AC_OUTPUT M4 macros. You don’t need to know anything about the M4 language to use these macros; they’re already written for you, and all of the ones relevant to Autotools are defined in the documentation.

Open the file in your favorite text editor. The AC_INIT macro may consist of the package name, version, an email address for bug reports, the project URL, and optionally the name of the source TAR file.

The AC_OUTPUT macro is much simpler and accepts no arguments.

AC_INIT([penguin], [2019.3.6], [seth@example.com])
AC_OUTPUT

If you were to run autoconf at this point, a configure script would be generated from your configure.ac file, and it would run successfully. That’s all it would do, though, because all you have done so far is define your project’s metadata and called for a configuration script to be created.

The next macros you must invoke in your configure.ac file are functions to create a Makefile. A Makefile tells the make command what to do (usually, how to compile and link a program).

The macros to create a Makefile are AM_INIT_AUTOMAKE, which accepts no arguments, and AC_CONFIG_FILES, which accepts the name you want to call your output file.

Finally, you must add a macro to account for the compiler your project needs. The macro you use obviously depends on your project. If your project is written in C++, the appropriate macro is AC_PROG_CXX, while a project written in C requires AC_PROG_CC, and so on, as detailed in the Building Programs and Libraries section in the Autoconf documentation.

For example, I might add the following for my C++ program:

AC_INIT([penguin], [2019.3.6], [seth@example.com])
AC_OUTPUT
AM_INIT_AUTOMAKE
AC_CONFIG_FILES([Makefile])
AC_PROG_CXX

Save the file. It’s time to move on to the Makefile.

Autotools Makefile generation

Makefiles aren’t difficult to write manually, but Autotools can write one for you, and the one it generates will use the configuration options detected during the ./configure step, and it will contain far more options than you would think to include or want to write yourself. However, Autotools can’t detect everything your project requires to build, so you have to add some details in the file Makefile.am, which in turn is used by automake when constructing a Makefile.

Makefile.am uses the same syntax as a Makefile, so if you’ve ever written a Makefile from scratch, then this process will be familiar and simple. Often, a Makefile.am file needs only a few variable definitions to indicate what files are to be built, and where they are to be installed.

Variables ending in _PROGRAMS identify code that is to be built (this is usually considered the primary target; it’s the main reason the Makefile exists). Automake recognizes other primaries, like _SCRIPTS, _DATA, _LIBRARIES, and other common parts that make up a software project.

If your application is literally compiled during the build process, then you identify it as a binary program with the bin_PROGRAMS variable, and then reference any part of the source code required to build it (these parts may be one or more files to be compiled and linked together) using the program name as the variable prefix:

bin_PROGRAMS = penguin
penguin_SOURCES = penguin.cpp

The target of bin_PROGRAMS is installed into the bindir, which is user-configurable during compilation.

If your application isn’t actually compiled, then your project doesn’t need a bin_PROGRAMS variable at all. For instance, if your project is a script written in Bash, Perl, or a similar interpreted language, then define a _SCRIPTS variable instead:

bin_SCRIPTS = bin/penguin

Automake expects sources to be located in a directory called src, so if your project uses an alternative directory structure for its layout, you must tell Automake to accept code from outside sources:

AUTOMAKE_OPTIONS = foreign subdir-objects

Finally, you can create any custom Makefile rules in Makefile.am and they’ll be copied verbatim into the generated Makefile. For instance, if you know that a temporary value needs to be replaced in your source code before the installation proceeds, you could make a custom rule for that process:

all-am: penguin
        touch bin/penguin.sh
       
penguin: bin/penguin.sh
        @sed "s|__datadir__|@datadir@|" $< >bin/$@

A particularly useful trick is to extend the existing clean target, at least during development. The make clean command generally removes all generated build files with the exception of the Automake infrastructure. It’s designed this way because most users rarely want make clean to obliterate the files that make it easy to build their code.

However, during development, you might want a method to reliably return your project to a state relatively unaffected by Autotools. In that case, you may want to add this:

clean-local:
        @rm config.status configure config.log
        @rm Makefile
        @rm -r autom4te.cache/
        @rm aclocal.m4
        @rm compile install-sh missing Makefile.in

There’s a lot of flexibility here, and if you’re not already familiar with Makefiles, it can be difficult to know what your Makefile.am needs. The barest necessity is a primary target, whether that’s a binary program or a script, and an indication of where the source code is located (whether that’s through a _SOURCES variable or by using AUTOMAKE_OPTIONS to tell Automake where to look for source code).

Once you have those variables and settings defined, you can try generating your build scripts as you see in the next section, and adjust for anything that’s missing.

Autotools build script generation

You’ve built the infrastructure, now it’s time to let Autotools do what it does best: automate your project tooling. The way the developer (you) interfaces with Autotools is different from how users building your code do.

Builders generally use this well-known sequence:

$ ./configure
$ make
$ sudo make install

For that incantation to work, though, you as the developer must bootstrap the build infrastructure. First, run autoreconf to generate the configure script that users invoke before running make. Use the –install option to bring in auxiliary files, such as a symlink to depcomp, a script to generate dependencies during the compiling process, and a copy of the compile script, a wrapper for compilers to account for syntax variance, and so on.

$ autoreconf --install
configure.ac:3: installing './compile'
configure.ac:2: installing './install-sh'
configure.ac:2: installing './missing'

With this development build environment, you can then create a package for source code distribution:

$ make dist

The dist target is a rule you get for "free" from Autotools.
It’s a feature that gets built into the Makefile generated from your humble Makefile.am configuration. This target produces a tar.gz archive containing all of your source code and all of the essential Autotools infrastructure so that people downloading the package can build the project.

At this point, you should review the contents of the archive carefully to ensure that it contains everything you intend to ship to your users. You should also, of course, try building from it yourself:

$ tar --extract --file penguin-0.0.1.tar.gz
$ cd penguin-0.0.1
$ ./configure
$ make
$ DESTDIR=/tmp/penguin-test-build make install

If your build is successful, you find a local copy of your compiled application specified by DESTDIR (in the case of this example, /tmp/penguin-test-build).

$ /tmp/example-test-build/usr/local/bin/example 
hello world from GNU Autotools

Time to use Autotools

Autotools is a great collection of scripts for a predictable and automated release process. This toolset may be new to you if you’re used to Python or Bash builders, but it’s likely worth learning for the structure and adaptability it provides to your project.

And Autotools is not just for code, either. Autotools can be used to build Docbook projects, to keep media organized (I use Autotools for my music releases), documentation projects, and anything else that could benefit from customizable install targets.


hpr3040 :: Why use GNU Autotools

6 good reasons you should be using a build system

Hosted by klaatu on 2020-03-27 is flagged as Clean and released under a CC-BY-SA license.
Tags: autotools,build,make.
Listen in ogg, spx, or mp3 format. Comments (0)

GNU Autotools is a build system that helps you distribute your code in a predictable and reliable way. Build systems offer many benefits, including:

  1. Standard and automate-able build process
  2. hooks into packaging systems (RPM, DEB, Slackbuilds, Flatpak, Snap, and so on)
  3. version reporting
  4. build for various OSes
  5. you get lots of code to handle every possible corner case, for free
  6. with a single configuration, you can build your project as the developer, build it for packagers, and enable users to build it for themselves

Next up: how to use GNU Autotools


hpr3039 :: Making a Raspberry Pi status display

A project making use of my Pi 3A+, an old monitor and MagicMirror2


Hosted by Dave Morriss on 2020-03-26 is flagged as Explicit and released under a CC-BY-SA license.
Tags: Raspberry Pi,VGA monitor,MagicMirror2,MQTT,Node.js,Electron.
Listen in ogg, spx, or mp3 format. Comments (0)

Introduction

I have had a project on my To Do list for a while: to make a status display from a Raspberry Pi. My vision was to show the state of various things including some HPR stuff, and I had imagined setting up a Pi with a monitor and controlling it over SSH.

I started on the project over the Christmas period 2019. I have a Raspberry Pi 3A+, which is a sort of souped-up Pi Zero, which I bought on a whim and hadn’t found a use for (Yannick reviewed this RPi model in show 2711). I also had an old square Dell monitor from about 15 years ago which still worked (at least to begin with).

I had imagined I’d write some software of my own with a web front end which ran various tasks to monitor things.

However, in my researches I came across MagicMirror2 which I thought I might be able to use instead of writing my own thing.

Long notes

I have provided detailed notes as usual for this episode, and these can be viewed here.


hpr3038 :: Solo Magic

All the magic without the gathering

Hosted by klaatu on 2020-03-25 is flagged as Clean and released under a CC-BY-SA license.
Tags: magic, mtg.
Listen in ogg, spx, or mp3 format. Series: Tabletop Gaming | Comments (0)

This episode outlines my single-player mod for the Magic: The Gathering card game.


hpr3037 :: Ambient recording at Union Station

Ambient recording in the main hall at Union Station, Chicago


Hosted by Archer72 on 2020-03-24 is flagged as Clean and released under a CC-BY-SA license.
Tags: soundscape, train station.
Listen in ogg, spx, or mp3 format. Series: Sound Scapes | Comments (0)

This was recorded in the main hall at Union Station in Chicago, Illinois.
There was a brief security announcement about watching for bags or package left unattended.


hpr3036 :: WiiU is dead long live WiiU!

How to approach dea-ish mod communities

Hosted by operat0r on 2020-03-23 is flagged as Explicit and released under a CC-BY-SA license.
Tags: wiiu,modding,hacking,tcpgecko,android,ssl pinning,games.
Listen in ogg, spx, or mp3 format. Comments (0)


hpr3035 :: Decentralised Hashtag Search and Subscription in Federated Social Networks

ActivityPub Conference 2019, a proposal for how we can use hashtags to find and subscribe to content


Hosted by Ahuka on 2020-03-20 is flagged as Clean and released under a CC-BY-SA license.
Tags: social media, alternative, Fediverse, ActivityPub, Hashtags.
Listen in ogg, spx, or mp3 format. Series: Social Media | Comments (0)

The ActivityPub Conference of 2019 was held in Prague. This is about a talk a proposal for a method to allow searching for hashtags in a decentralized Fediverse environment so that we can find, and subscribe to, content of interest. https://www.zwilnik.com/?page_id=1091


hpr3034 :: How to bridge Freenode IRC rooms to Matrix.org

Thaj builds upon a previous episode by Clacke to deep dive into bridging IRC to Matrix.org


Hosted by Thaj Sara on 2020-03-19 is flagged as Clean and released under a CC-BY-SA license.
Tags: Freenode, IRC, Matrix.org, Riot.im, Social Media.
Listen in ogg, spx, or mp3 format. Series: Social Media | Comments (1)

  • Attribution

  • Matrix.org is a Free, open source, and decentralized messaging system. One of the strong points of this system is its ability to bridge multiple protocols together into one interface.

  • Riot.im

  • Bridging to Freenode's IRC server is built into Matrix.org. If you already have a registered Nick on Freenode it is a simple process to associate your Matrix and Freenode accounts.

  • Steps to bridge to a Freenode IRC room

    1. Start a direct message with @freenode_NickServ:matrix.org and send the command identify nick pass (replacing nick and pass with your credentials).
    2. Direct message @appservice-irc:matrix.org with the command !storepass nick:pass
    3. Join the room #freenode_#oggcastplanet:matrix.org. You can really join any room on freenode with #freenode_#CHANNAME:matrix.org
    4. PROFIT!!!!

hpr3033 :: 32 Bit Time Travel

Linux Inlaws - a podcast on topics around free and open source software

Hosted by monochromec on 2020-03-18 is flagged as Explicit and released under a CC-BY-SA license.
Tags: Linux Inlaws, free open source software, revolution, FLOSS.
Listen in ogg, spx, or mp3 format. Series: Linux Inlaws | Comments (0)

For show notes, please visit https://linuxinlaws.eu


hpr3032 :: piCore on a Raspberry Pi 1 Model B

How I revived my Raspberry Pi Model 1 B with piCore and a tiny SD card.

Hosted by Claudio Miranda on 2020-03-17 is flagged as Clean and released under a CC-BY-SA license.
Tags: raspberrypi,rpi,linux,bsd.
Listen in ogg, spx, or mp3 format. Comments (1)

In this episode, I discuss how I revived my Raspberry Pi 1 Model B using piCore, a specialized version of Tiny Core Linux for the Raspberry Pi, on a 128 MB SD card that I had laying around. I also mention nanoBSD and Alpine Linux as possible alternatives to try out.


Previous five weeks

hpr3031 :: Daniel Persson - Me? Me! hosted by Daniel Persson

Released: 2020-03-16. Duration: 00:18:51. Flag: Clean.
Tags: biography.
I talk about who I am and where I come from and what my interests are.

hpr3030 :: My new Samsung tablet hosted by MrX

Released: 2020-03-13. Duration: 00:28:06. Flag: Explicit.
Tags: Android, Tablet.
A general discussion about my new 10.5 inch Samsung Galaxy tablet

hpr3029 :: At Union Station with a train delay hosted by Archer72

Released: 2020-03-12. Duration: 00:05:47. Flag: Clean. Series: Sound Scapes.
Tags: soundscape, trains.
This is a soundscape while waiting for a train at Union Station.

hpr3028 :: Monads and Haskell hosted by crvs

Released: 2020-03-11. Duration: 00:21:15. Flag: Explicit. Series: Haskell.
Tags: Haskell, Programming, Math.
A hopefully not too rambly "introduction" to functors and monads in and out of haskell

hpr3027 :: What is quantum computing and why should we care? hosted by mightbemike

Released: 2020-03-10. Duration: 00:25:15. Flag: Clean.
Tags: quantum computing.
What is all the quantum computing hype about & what is it that quantum computers will be able to do?

hpr3026 :: Hex Bug and Battle Bots hosted by operat0r

Released: 2020-03-09. Duration: 00:18:40. Flag: Clean.
Tags: robots,hexbug,battlebots,RC,IR.
Review/mods of fun Hex Bug and Battle Bots

hpr3025 :: Keep unwanted messages off the Fediverse hosted by Ahuka

Released: 2020-03-06. Duration: 00:14:41. Flag: Clean. Series: Social Media.
Tags: social media, alternative, Fediverse, ActivityPub, SPAM.
ActivityPub Conference 2019, techniques for fighting SPAM and unwanted messages in the Fediverse.

hpr3024 :: A funny thing happened the other day hosted by MrX

Released: 2020-03-05. Duration: 00:04:19. Flag: Explicit.
Tags: story, audio, sound.
Describing a funny thing that happened the other day.

hpr3023 :: Critique My Script, Episode 1 - Qots-Crew-Gen hosted by Carl

Released: 2020-03-04. Duration: 00:13:02. Flag: Clean.
Tags: Shell Script,Random Numbers,Awk.
Discussion of using a shell script to randomly generate a ten man aircrew.

hpr3022 :: FOSDEM 2020 Stand Interviews hosted by Ken Fallon

Released: 2020-03-03. Duration: 01:32:58. Flag: Clean. Series: Interviews.
Tags: FOSDEM 2020.
Interviews with some of the stands at FOSDEM 2020

hpr3021 :: HPR Community News for February 2020 hosted by HPR Volunteers

Released: 2020-03-02. Duration: 00:54:32. Flag: Explicit. Series: HPR Community News.
Tags: Community News.
Call for shows is open. Ken and eventually Dave discuss the shows, media and development plans.

hpr3020 :: Validating data in Haskell hosted by tuturto

Released: 2020-02-28. Duration: 00:25:00. Flag: Clean. Series: Haskell.
Tags: validation, algebraic data types, json.
tuturto talks about wow to validate incoming http request before acting on them

hpr3019 :: Linux Inlaws S01E02 FOSDEM shenanigans hosted by monochromec

Released: 2020-02-27. Duration: 01:05:29. Flag: Explicit. Series: Linux Inlaws.
Tags: free open source software, revolution, FLOSS.
Linux Inlaws - a podcast about on topics around free and open source software

hpr3018 :: Encrypted edit hosted by klaatu

Released: 2020-02-26. Duration: 00:20:34. Flag: Clean.
Tags: GPG, privacy.
Klaatu talks about editing and viewing encrypted files in a tmpfs in RAM

hpr3017 :: Developing Black and White Film hosted by Paul Quirk

Released: 2020-02-25. Duration: 00:42:24. Flag: Clean.
Tags: Photography,film,developing,black and white.
Join me as I develop my first roll of black and white film since over 30 years ago.

hpr3016 :: Nixie tube clock and friends! hosted by operat0r

Released: 2020-02-24. Duration: 00:14:34. Flag: Clean.
Tags: DIY,nixie tube,LED,electronics .
I chat about Novice Nixie tubes and tronics soldering etc

hpr3015 :: ActivityPub Conference 2019 - The Semantic Social Network hosted by Ahuka

Released: 2020-02-21. Duration: 00:07:18. Flag: Clean. Series: Social Media.
Tags: social media, alternative, Fediverse, ActivityPub.
ActivityPub Conference 2019, building a Semantic Social Network

hpr3014 :: A Headless Raspberry Pi Streaming Radio hosted by Jon Kulp

Released: 2020-02-20. Duration: 00:17:48. Flag: Clean.
Tags: Raspberry Pi, Internet Radio, Streaming Radio, Radio, Streaming Audio, Ubuntu, Ubuntu Server.
I use a Raspberry Pi to make a streaming radio device for my pillow speaker.

hpr3013 :: Bash Tips - 21 hosted by Dave Morriss

Released: 2020-02-19. Duration: 00:41:37. Flag: Explicit. Series: Bash Scripting.
Tags: Bash,variable,environment.
Environment variables

hpr3012 :: Sample episode from Wikipediapodden hosted by Ken Fallon

Released: 2020-02-18. Duration: 00:08:38. Flag: Explicit.
Tags: fosdem, wikipediapodden, swedish, sweden.
An English microsode of their Swedish language podcast about Wikipedia.

hpr3011 :: Linux is HARD rant with Intel graphics hosted by operat0r

Released: 2020-02-17. Duration: 00:20:28. Flag: Explicit.
Tags: linux,video,DIY,xbmc,kodi,ubuntu,debian.
I go over my issues around Linux in general specifically Video issues

hpr3010 :: FOSDEM first impressions hosted by Andrew Conway

Released: 2020-02-14. Duration: 00:27:18. Flag: Clean.
Tags: fosdem,conference,podcasts,creative commons.
Impressions from my first attendance at FOSDEM.

hpr3009 :: Linux Inlaws S01 E01 hosted by monochromec

Released: 2020-02-13. Duration: 00:59:30. Flag: Explicit. Series: Linux Inlaws.
Tags: free open source software revolution.
Linux Inlaws - a podcast about on topics around free and open source software

hpr3008 :: Hacker Public Radio 2019-20 New Year Show Episode 5 hosted by Kevin Wisher

Released: 2020-02-12. Duration: 01:56:53. Flag: Explicit.
Tags: 2019-20 New Year Show.
Eighth Annual New Year Show: war stories and more war stories

hpr3007 :: Photography 101 hosted by Paul Quirk

Released: 2020-02-11. Duration: 00:24:28. Flag: Clean.
Tags: Photography,101,digital,film,camera.
I tell you everything I know about the basics of photography

hpr3006 :: Hijack Auxiliary Input of your car! hosted by operat0r

Released: 2020-02-10. Duration: 00:35:59. Flag: Explicit.
Tags: Car Audio,DIY,music,cars,auto.
I talk about my Q40 and getting Auxiliary Input when your car does not have one

hpr3005 :: Is ActivityPub Paving The Way to Web 3.0? hosted by Ahuka

Released: 2020-02-07. Duration: 00:12:15. Flag: Clean. Series: Social Media.
Tags: social media, alternative, Fediverse, ActivityPub.
ActivityPub Conference 2019, a talk about whether ActivityPub is leading the way to Web 3.0

hpr3004 :: Fixing simple audio problems with Audacity hosted by Dave Morriss

Released: 2020-02-06. Duration: 00:13:28. Flag: Explicit.
Tags: audio,Audacity,effects,problem solving.
Sharing a few experiences with Audacity that may be helpful to others

hpr3003 :: Hacker Public Radio 2019 2020 New Year Show Episode 4 hosted by Kevin Wisher

Released: 2020-02-05. Duration: 02:41:47. Flag: Explicit.
Tags: 2019-20 New Year Show.
Eighth Annual New Year Show. From Star Wars to NASA

hpr3002 :: World of Commodore 2019 Episode 8: Vote of thanks hosted by Paul Quirk

Released: 2020-02-04. Duration: 00:19:16. Flag: Explicit.
Tags: Commodore,64,PET, Vic 20, amiga,World of Commodore, TPUG.
This is the final episode of the World of Commodore 2019 mini series.

hpr3001 :: HPR Community News for January 2020 hosted by HPR Volunteers

Released: 2020-02-03. Duration: 00:44:09. Flag: Explicit. Series: HPR Community News.
Tags: Community News.
HPR Volunteers Dave and Ken talk about shows released and comments posted in January 2020

hpr3000 :: Chopin Free project hosted by Paul Quirk

Released: 2020-01-31. Duration: 00:23:53. Flag: Clean.
Tags: musopen, Frédéric Chopin.
An effort to produce royalty and copyright free versions of Frédéric Chopin work.

hpr2999 :: SQRL - Secure Quick Reliable Login hosted by Daniel Persson

Released: 2020-01-30. Duration: 00:24:02. Flag: Explicit.
Tags: security, login method.
In this podcast we talk about what SQRL is and how it works.

hpr2998 :: Hacker Public Radio 2019-20 New Year Show Episode 3 hosted by Kevin Wisher

Released: 2020-01-29. Duration: 02:32:44. Flag: Explicit.
Tags: 2019-20 New Year Show.
Eighth Annual New Year Show: The US is awake

hpr2997 :: World of Commodore 2019 Episode 7: Video Playback with 1541 Ultimate hosted by Paul Quirk

Released: 2020-01-28. Duration: 00:19:21. Flag: Clean. Series: Hobby Electronics.
Tags: Commodore 64,retro,computing,games,gamer,vintage,video,World of Commodore,TPUG.
In this seventh episode, Greg returns to tell us how he got full video playback on a Commodore 64.

hpr2996 :: Spideroak Update hosted by operat0r

Released: 2020-01-27. Duration: 00:07:45. Flag: Explicit.
Tags: cloud backup,computers,linux,spideroak one,spideroak.
I give you an update on my cloud backup solution and fixes

hpr2995 :: ActivityPub Conference 2019 - ActivityPub: past, present, future hosted by Ahuka

Released: 2020-01-24. Duration: 00:16:01. Flag: Clean. Series: Social Media.
Tags: social media, alternative, Fediverse, ActivityPub.
ActivityPub Conference 2019 Keynote

hpr2994 :: Wrestling As You Like It Episode 3 hosted by TheDUDE

Released: 2020-01-23. Duration: 00:22:07. Flag: Explicit.
Tags: Pro Wrestling.
A podcast on why I like wrestling and how it works to draw in fans.

hpr2993 :: Hacker Public Radio 2019-20 New Year Show Episode 2 hosted by Kevin Wisher

Released: 2020-01-22. Duration: 02:34:58. Flag: Explicit.
Tags: 2019-20 New Year Show, HPRNYS.
Eighth Annual New Year Show with ThinkPads, Steam engines and Corporate America philosophy

hpr2992 :: World of Commodore 2019 Episode 6: Introduction to C64 OS hosted by Paul Quirk

Released: 2020-01-21. Duration: 00:35:59. Flag: Clean. Series: Hobby Electronics.
Tags: Commodore,64,OS,World of Commodore.
Greg Naçu presents to us his new operating system to the Commodore 64

Older Shows

Get a full list of all our shows.