[SLUG] [semi-rant] Debian, DFSG, Gentoo and .NET

From: Derek Glidden (dglidden@illusionary.com)
Date: Wed Jul 28 2004 - 12:55:49 EDT


On Jul 27, 2004, at 10:16 PM, Paul M Foster wrote:

> I just noticed that many Debian packages now include "dfsg" in the name
> of the actual .deb files. What is this? A search of the Debian list
> archives turns up more non-useful data than I can shake a stick at, and
> google isn't any better. Does this have something to do with Debian's
> complaints about X's license?

Ugh...

Can I just list this as "Yet Another Reason I've Dumped Debian In Favor
Of A Different Distro That Isn't More Concerned With Semantics,
Politics And Splitting Hairs As It Is About Just Making The Damn Thing
Work"?

I guess I should give kudos to the Debian development team for deciding
NOT to implement the new DFSG "standards" BEFORE releasing the next
"stable" version of the distro and pushing the release date back yet
another 16 years.

I never thought I'd see the time when distros took longer to cycle than
major kernel releases.

Paul, maybe you should take a serious gander at Gentoo. I've pretty
much converted entirely at this point, and will be totally debian-free
as soon as I can decomission the current illusionary.com and put its
replacement online. So far I've been really happy with it. It has the
same "keep your hands off my config files" sysadmin mentality that
attracted me to Debian, but without all the political baggage.

The whole "compile things at install-time" thing is the Gentoo
"feature" that people most like to make fun of, but I've given it a lot
of thought since I started playing with it and decided I was
happy/comfortable enough to switch.

LISP guru Paul Graham wrote a very thoughtful essay called "The
Hundred-year Language" in which he theorizes on what the programming
language being used 50 or 100 years from now might look like.
Extrapolating from the fact that a programmer of 50 years ago would be
perfectly comfortable using Perl or Ruby or some other "modern"
programming language, and looking at what has changed since then, he
theorizes that we could start designing and writing "the 100-year
language" now and simply optimize features (or optimize them out) to
work on the highest-end hardware of today.

What's that got to with Gentoo? Ok, I'm getting there, bear with me.

I've been looking at Mono lately from a developer's perspective.

Everyone sit down because this is going to be a shock...

Microsoft did something right for once. They got the CLR (Common
Language Runtime) part of this whole .NET mess right and it's something
I'm very jealous of as a Java programmer who is getting so over all of
Java's... umm, let's call them idiosyncrasies for PC-ness. The fact
that Mono implements this on platforms other than Windows has me very
interested.

The idea is that there's a _generic_ VM to which you can compile
multiple languages so that they can all run together on the same
runtime platform, unlike the Java VM which is so tailored to the Java
language that it's very very difficult to shoehorn any other language
into producing viable Java bytecode that can run on a JVM. The CLR in
.NET has some specific implementation stupidities IMHO (not the least
of which is the fact that it's mainly tied to Windows APIs...) but the
idea in general is incredibly appealing.

I'd LOVE to have a cross-platform VM that will run my byte-compiled
Perl, Python, Java, LISP, Ruby, Eiffel, Modula, C/C++ or even shellcode
all in the same VM and able to communicate with each other through
mechanisms less complicated than having to write native-language (i.e.
C) interfaces. At one point, this interface was supposed to be this
CORBA stuff, which also had the benefit of being network-transparent,
but if anyone can point out a less intuitive, less performant way of
getting components in multiple languages to talk to each other, I'd
love to know. And thus, other than some dedicated weirdos (who either
invested too much time in learning, or have too much legacy code that
needs it) CORBA is dead, dead, dead because of it's inherent
complexity, slowness and overall braindeadedness.

(I'm getting to the Gentoo thing, really...)

One of the other neat aspects of the CLR is run-time compliation. Not
Just-in-time compilation like with Java, but actual real run-time
native compilation that emits a native binary the first time you run
the app. Since all languages compile to the same bytecode, you only
need to write one compiler that knows how to compile that bytecode to
native code and thusly you have a native-code compiler that can handle
any language capable of emitting CLR bytecode. Yes that could even
mean bash scripts could be compiled to native code, which should make
your head spin around 270 or even 360 degrees if you really think about
it. Sure that compiler is a lot more complex than just compiling C
because you have to deal with things like garbage collection and memory
management and other abstractions that have to be broad enough to cover
any language you might want to write, but heck, the Mono Project's
already got one!

And so THAT is what Gentoo has to do with Paul Graham, LISP and
Microsoft.

Microsoft, through .NET and the CLR and thus Mono, is pushing the idea
that compilation of your code should happen at run-time, not when the
developer writes it. You're giving the compiler the chance to optimize
the application for your particular architecture and platform as well.
It's basically the same thing that Gentoo does, only pushing it up a
level by saying the whole OS is compiled at run-time.

The way Gentoo handles it, pushing the compilation step down to the
individual machines, you're not only optimizing for your particular
architecture, but through the "USE" settings, you're optimizing for the
particular settings on that individual machine. It's not that big a
deal for people familiar with the "configure; make; make install" cycle
of most open-source software as it is; it just streamlines the process
and makes it easier for people to do the "configure; make; make
install" without having to know all the switches for every single app
you want to install.

And in ten years or so, much less fifty or a hundred, I'm betting that
virtually _every_ piece of software is going to be distributed as some
kind of bytecode or semi-compiled code and compiled natively at
run-time to be optimized for the particular architecture and platform,
not just the usual .tar.bz2 type we OSS types are already comfortable
with. (It's one thing Paul Graham missed in his article; I guess he
doesn't pay ANY attention to Microsoft at all...) Given Moore's Law
holds up for another ten years, we'll have the CPU power that we won't
even notice if the "configure; make; make install" step is
transparently built into every application we try to run. And if
you're doing that with software, why not go ahead and do it with OS
components as well? I bet whatever Microsoft comes up with
post-Longhorn is going to leverage the hell out of the CLR and bytecode
idea. (Albeit in a way that locks you even tighter to Microsoft, I'm
sure, with built-in DRM, runtime licensing, and all that.)

So you see, Gentoo is just "The Hundred-Year Linux Distro." Why not
get onboard now?

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
"I think that's what they mean by |
"nickels a day can feed a child." | http://www.eff.org/
I thought, "How can food be so | http://www.anti-dmca.org/
cheap over there?" It's not, they |--------------------------
just eat the nickels." -- Peter Nguyen

-----------------------------------------------------------------------
This list is provided as an unmoderated internet service by Networked
Knowledge Systems (NKS). Views and opinions expressed in messages
posted are those of the author and do not necessarily reflect the
official policy or position of NKS or any of its employees.



This archive was generated by hypermail 2.1.3 : Fri Aug 01 2014 - 13:31:10 EDT