Syndication

When packaging software for Debian, there exist two important assumptions:

Compilation is done natively

Potentially all of Debian is available at compile time

Both assumptions make the life of a package maintainer much easier and they do
not create any problem unless you are one of the unlucky few who want to run
Debian on an architecture that it does not yet exist for.

You will then have to use either cross compile a set of base packages (which is
hard because packages are built and tested to built natively, not cross - perl
is a big blocker of building the minimal set of packages cross but through
multiarch other packages become easier to cross build) or use other
distributions like OpenEmbedded or Gentoo which you compiled (or retrieved
otherwise) for that new architecture to hack a core of Debian source packages
until they build a minimal Debian system that you can chroot into and continue
natively building the rest of it. But even if you manage to get that far you
will continue to be plagued by cyclic build and runtime dependencies. So you
start to hack source packages so that they drop some dependencies and you can
break enough cycles to advance step by step.

The Debian ports page lists 24 ports of Debian,
so despite its unpleasant nature, porting it is something that is not done
seldom.

The process as laid out above has a number of drawbacks:

The process is mostly manual and reinvented every time it is done.

If you can't cross compile something, then you need another distribution for
the bootstrapping process. Debian itself should be sufficient.

Its complexity and manual nature prevents architectures with little
workforce behind them from catching up to the main archive.

It also avoids that Debian exists in CPU optimized sub-arch builds.

If Debian would provide a set of core packages that are cross-compilable and
which suffice for a minimal foreign build system, and if it would also have
enough source packages that provide a reduced build dependency set so that all
dependency cycles can be broken, building Debian for a yet unknown architecture
could be mostly automated.

The benefits would be:

Putting Debian on a foreign architecture would (in the best case) boil down
to making the code cross-compile for and native-compile on that
architecture.

Debian would not need any other distribution to be ported to a different
architecture. This would make Debian even more "universal".

Lagging architectures can be more easily updated or rebooted than when they
were initially created.

Debian optimized for specific CPUs (Raspberry Pie, OpenMoko...) would be
more attractive.

With three of this year's GSoC projects, this dream seems to come into reach.

There is the "Multiarch
Cross-Toolchains"
project by Thibaut
Girka
and mentored by Hector Oron and Marcin Juszkiewicz. Cross-compiling toolchains
need packages from the foreign architecture to be installed alongside the
native libraries. Cross-compiler packages have been available through the
emdebian repositories but always were more of a hack. With multiarch, it is now
possible to install packages from multiple architectures at once, so that
cross-compilation toolchains can be realized in a proper manner and therefor
can also enter the main archives. Besides creating multiarch enabled
toolchains, he will also be responsible for making them build on the Debian
builld system as cross-architecture dependencies are not yet supported.

There is also the "Bootstrappable
Debian"
project by Patrick "P. J."
McDermott
and mentored by Wookey and Jonathan Austin. He will make a small set of source
packages multiarch cross-compilable (using cross-compilers provided by Thibaut
Girka) and add a Build-Depends-StageN header to critical packages so that they
can be built with reduced build dependencies for breaking dependency cycles. He
will also patch tools as necessary to recognize the new control header.

And then there is my project: "Port bootstrap build-ordering
tool"
(Application).
It is mentored by Wookey and Pietro Abate. In contrast to the other two, my
output will be more on the meta-level as I will not modify any actual Debian
package or patch Debian tools with more functionality. Instead the goal of this
project is threefold:

find the minimal set of source packages that have to be cross compiled

help the user to find packages that are good candidates for breaking
build dependency cycles through added staged build dependencies or by
making them cross-compilable

develop a tool that takes the information about packages that can be
cross compiled or have staged build dependencies to output an ordering
with which packages must be built to go from nothing to a full archive