Version 1.1.0

lecture: Modern Software Packaging for Developers

Wait, how to install your FOSS project again?

Spack logo text 64

Writing FOSS software is fun. But re-using software of other people tends to be the opposite of fun, often because we can not even install it from source.

This talk will present how to properly open source software for reusability. We will introduce the concept of software packaging, existing solutions from well-known Linux distributions and modern all-rounders such as conda up to from-source distributing package managers such as spack. We will introduce the concepts, benefits and short-comings of selected solutions and how one can not only install but also switch seamlessly between software environments without spawning a full-flavored VM/docker/vagrant environment.

Our special focus is set on developers (and users) of open source software, e.g. with Python/C/C++ dependencies, transient dependency trees and special performance requirements that are not satisfied with a simple "ship me a pre-build 64bit binary" but want more flexible control, including an arbitrary number of parallel installed versions of compilers and dependencies. We will also graze the world of containers, virtual machines and continuous integration and highlight why we need better, automated ways to provision those. (Hint: via a package manager!)

I thought I am a decent C/C++ programmer until someone tried to build upon libraries I developed and contributed to. Yes, of course you should use modern build systems such as CMake but how to express an easy install of your transient dependencies? And as we are developing, how can we just quickly try our software against various compilers and alternative versions/implementations of dependencies?

Every script kiddy today (no offense, pun intended) can just run
pip install --user foo@someVersion

or if you want

npm install bar

and is done with it. But what if software is a bit more complex, has nifty C/C++/Fortran/environment/compiler-flag/patched-version/build-system/... constrains and shall be build against dependencies that are build with a variety of compilers and standard libraries? All these are problems are touched first when distributing software, e.g. while trying to package it. Let us collaborate more seamlessly, "works on my machine" must not be the end of what we aim for.

This talk will present a few common issues that can occur when distributing software, especially when its not only containing interpreted scripts. As developers, we are not satisfied with single-version installs from our favorite package repository and want to be able to interact with any dependency down the rabbit hole.

From a user's point of view, we will introduce the concepts of conventional (binary) package formats and environment management systems. We will show where they work great ("fixed" end-user distributions) and where they fail (continuous integration/testing, development, sharing pre-releases, parallel installs of conflicting versions, etc.). Learning from the short-comings of existing solutions, we will introduce the spack package manager that allows packing, installing and switching environments in a convenient one-liner but at the same time can transparently build, tweak and verify any dependency from source (in any version).


Day: 2017-10-22
Start time: 15:00
Duration: 00:45
Room: Museumskino

Language: de


Concurrent Events