Episode: 4562
Title: Software development doesn't end until it's packaged
Source: https://hub.hackerpublicradio.org/ccdn.php?filename=/eps/hpr4562/hpr4562.mp3
Transcribed: 2026-07-31 16:13:57 (official HPR transcript)

---

This is Hacker Public Radio Episode 4562, for 2026-01-27
Today's show is entitled, "Software development doesn't end until it's packaged"
The host is Klaatu and the duration is 00:11:16
The flag is Clean, and the license is CC-BY-SA
The summary is "Creating an installable package for your application is a great quality assurance step"
Hey, everybody, this is Clattu. Most software development I've done has been utilities for highly specific workflows.
I've written code to ensure that metadata for a company's custom file formats gets copied along with the rest of the data when the file gets archived or
code that ensures a search field doesn't mangle its input. Lots of git hooks, file converters, parsers, and of course my fair share of
dirty hacks. And because most software projects I work on are designed for a specific task, very few of them have required packaging.
The utilities that I've written have often been just integrated into a larger code base that I'm not responsible for or else distributed across an infrastructure by some admin.
It's kind of like a magic trick which has made my life conveniently easier, but as magic does, it is also tricked me into thinking that my development work is done once I can prove that my code does its job.
The reality is I humbly submit that code development isn't actually done until you can deliver it to your users in a format they can install.
I don't think I'm alone in forgetting that software delivery is the real final product. There are many reasons some developers stop short of providing an installable package for the code they've worked on for weeks or months or years.
But first of all, packaging is work and after writing and troubleshooting code for months sometimes you just want your work to be over just as soon as everything functions is expected.
Secondly, there are a lot of software package formats out there regardless of what platform you think you're delivering to.
It's just not reasonable to expect any developer to be able to package for every single platform that might benefit from the code.
However, I view packaging as part of quality assurance. There are lots of benefits you gain by packaging your code into an installer and you don't have to target every package format.
In fact, I think you get the benefits of packaging by creating just one package.
If you package your code as an installable file, whether it's an RPM file or a bash script or a flat pack reference or an app image or an EXE or MSI or anything else, you're checking your code base for consistency.
You know it or not, possibly more likely the packaging tool that you're using is checking your code for consistency.
You can pick whatever package format you're most comfortable with or the one that you think represents maybe the bulk of your target audience.
And you're sure to find that the packaging tool expects to be automated and like nobody wants to start packaging from scratch every time they update code.
So naturally, most packaging tools out there, the vast majority of them are designed to be configured ones for your code base and then to create updated packages for you each time your code base is updated.
If you're building a package for your project and discover that you have to manually intervene, then you've probably discovered what you have discovered a bug in your code.
Imagine you've got a project repository with a name in camel case.
And you hadn't noticed it before, but your code refers to itself in a mix of lower case and camel case depending on where you know what the reference is.
Your package build grinds to a halt because a variable used by the packaging tool suddenly can't find your code base because it was set to a lower case title, but the archive of your code is titled with camel case.
There's a difference there case case sensitivity matters and in most cases I guess I guess there's probably some packaging managers that don't care or packaging tools that don't that don't do that.
But I mean certainly on the vast majority of on a sensible system there's case sensitivity let's put it that way.
So if that happens to you if this example happens to you and it doesn't have to be case sensitivity you could be underscores dashes whatever.
It's also going to happen to every software package package or trying to take your code and package it up for their users so if you fix it for yourself once you fixed it for everyone else another benefit is dependency management believe it or not for decades one of the most common problems of software troubleshooting has been the phrase well works on my machine and no matter how many tools we developers have our disposal to make it easy to build and run software on a clean system.
It's still common to accidentally deliver software with surprised dependencies that you would forgotten about it's really really easy to forget to revert to like a clean snapshot in your virtual machine or to a to a fresh container or or maybe to a maybe not to a fresh container that tends to happen on its own but although maybe not depends on how you're running it.
But I mean maybe you're container the container that you you're using happens to have like a more recent version of a library then you'd realize or maybe you get the path of an important executable wrong and a script or you forget that not all computers ship with the thing that you take for granted most packaging tools won't stand for this they will break if this happens.
I can't count the number of times I've tried to deliver an RPM only to be reminded by RPM build that I haven't included the dash developer version of a dependency that's because many Linux distributions separate development libraries from the binaries so little things like that they get caught by the packaging tools and you would not notice it during development because obviously you would have all the development tools right that's just something that you would have on your.
development machine you may not literally fix every problem with dependency management by building a single package because again different systems might require different things and maybe you don't know about that but you can clearly identify at least what your code requires.
It only takes a single warning from your packaging tool for you to add a note to other packages about what they need to include in their own builds in terms of like dependencies or be sure to include the development libraries or whatever as an additional bonus it's also a good reminder to double check the licenses your project is using.
I know that in the haze of sort of desperate hacking to try to get something to just work it's it can be helpful to get a gentle reminder that you've linked to a library with a different light license than everything else or something like that.
A few packaging tools if any detect like the actual licensing requirements directly but sometimes all it takes at least for me is a reminder that you're using a thing to then trigger that sort of thing in your head of like oh right that that's that one thing with with a different license or that has a license that I should double check about or whatever and then finally.
I think every package that you make for your code base is an example package every meaning any package is an example package.
Once you've packaged your code you create an example for everyone coming to your project to turn it into a package of their own.
It doesn't matter that your package might be an RPM or a dead or just a TGZ for a front end like Slack build or arches a you are.
It's just the interaction between a packaging system and the input script that really matters and I think even a novice package maintainer is likely to be able like if they've gotten that far to like investigate you know how to package something they probably could can generally reverse engineer or tell.
what a packaging script is doing not maybe maybe not exactly what it is doing but they can see sort of the flow of data like if you look at a just a sample RPM for GNU hello that they're kind of everywhere online you can see the the spec file for them and then look at like an arch build for GNU hello again that's online it's easy to find.
Not that dissimilar that they have a bunch of header information about sort of the name of the application the version where to find the applications code the will maybe the license of something like that and then they have the build section and that's usually filled with like either macros or functions like percent sign prep percent sign auto setup I don't know what those are you what I do but pretend like we don't know what those are.
look that up online what what is percent prep in an RPM build spec well it's a it's a macro it's got a bunch of like things that it does automatically auto setup again it's a macro it does stuff percent build a macro it does stuff and so on until you kind of understand the flow you see there's a setup there's a which is configuration there's like a build step and then there's the install step and then there's a post install step and sure enough if you look at the arch a you are for this there's the sort of the setup.
that there's the the build function and there's the package function and those are doing things like dot slash configure dash dash prefix equals slash USR make and then eventually there's in the packaging section section there's the make destitor equals your package directory install a slack build again would be quite similar to all of that so.
Once you kind of see one or three of them you've kind of seen all of the rest you still have to cross reference the actual documentation and the specifications of that packaging format but you understand the the flow of logic that happens there there are differences between the mall a lot of them can leverage sort of the the built in.
benefits of of other systems like auto make or and build or may sound or ninja all all of the different sort of build sort of systems that exist out there so sometimes a packaging is simply just a matter of like getting files into the correct place you know maybe it's in the.
maybe it's in a specific RPM build directory or maybe it's in a specific directory with with other assets right next to it like in a slack build whatever the the setup it's just a matter of getting things into the right place and then triggering.
the the extraction of the source code and the building of the source code and then kind of package packaging it all up into a well a package so seeing that as an example is is I think really helpful for people because if they can read around.
whatever you chose whatever packaging format you chose to set as an example that they can take that away as kind of a quick start for their own package again I think packaging really is a step of quality assurance even though a packaging system is.
really just a front end for whatever build system your code uses anyway the rigor of creating a repeatable and automatable process for delivering your project is a helpful exercise for both you and for the people who come after you to try to help distribute your software it's it's kind of a form of of documentation quality assurance and it really is I think part of software development software development it's not over until it's package.
Thanks for listening talk to you next time.
You have been listening to Hacker Public Radio at Hacker Public Radio.org.
Today's show was contributed by a HPR listener like yourself.
If you ever thought of recording podcast, click on our upload link
to find out how easy it is.
Hosting for HPR has been kindly provided by an AnHonestHost.com, the Internet Archive,
rsync.net, and our mirror network.
Unless otherwise stated, today's show is released under a Creative Commons
Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) license.
