FOSDEM 2019

[Mikael Djurfeldt <mikael@djurfeldt.com>]

[-- Attachment #1: Type: text/plain, Size: 2586 bytes --]

It was a great experience and joy for me to meet some of you at FOSDEM
2019. Thank you all!

Now a piece of advice.

Everyone who works with Guile knows that it's crap and look with envy at
projects like Chez and Racket, right? Jim Blandy thinks that GNU should use
Python as its scripting language. Chris Webber (probably rightly) thinks
"look how much you can accomplish with Racket so quickly".

I've been there also. I have to confess that I have now and again regarded
Guile as crap since perhaps 1995 and there has been multiple occasions
where I have thought that basing the community effort on some other scheme
would make much more sense, and I have also always looked with envy on Chez
and mzscheme/Racket.

Yet, it is *amazing* to me how much progress Guile has made since I left.
I, for example, *love* the new language and compiler infrastructure.

But note now that Racket looks with envy on Chez and intends to base Racket
on Chez while Andy Wingo thinks that he can beat Chez performance.

My advice is this:

Idiots go around thinking that their own code is the best thing around.
Sensible people have a natural, and actually productive, tendency to be
critical about their own work. That is all good, unless it hurts the sense
of meaning and joy in your work.

Remember now first that we are all irrational creatures. We maybe *think*
sometimes that we are rational, because what we think looks rational in our
view. The problem is that the view is usually very limited, with, for
example, a limited set of presumptions.

For example: Guile is a piece of software, right? Wrong! It is a plant,
growing over time. Now, if we look over the fence into the other garden,
the plants there look much greener. But what will determine the ultimate
fate is not only the shape of it in the present moment, but also the genes
it carries, the quality of the soil, the amount of sunlight and the skills
of its gard[i]ners. We could have quit before we got GOOPS, or before we
got the native threading, or before the compiler tower, without which there
would be no chance to beat Chez.

If you look at one combination of some Guile features:

* easy embedding in applications
* support for multiple languages
* the compiler tower
* OO system with polymorphic dispatch and metaobject protocol
* nice, friendly and open community

I think it is pretty strong and impressive, and I wouldn't like to live
without it. It's especially important to look at Guile as a good breeding
ground for new amazing work.

That said, we should steal and collaborate all we can!

All the best,
Mikael

[-- Attachment #2: Type: text/html, Size: 3169 bytes --]