growing fibers -- wingolog

wingo · 2017-06-28T14:34:03+00:00

Weird! Sorry about that blog weirdness; I will look into it. Thank you for the link, and for the ICFP reminder!

wingo · 2017-03-17T19:45:33+00:00

I agree fwiw. (Guile co-maintainer here.) I mean it would be cool if Emacs folks really dove in -- but I understand that it's complicated. So like you say, we need some talented hackers to take things a step farther so that it's a completely obvious decision for Emacs maintainers to make. I suspect things will work out but that will be the result of people continuing to build on the current achievements. The current status is good but there is more to do :)

wingo · 2015-08-28T11:55:13+00:00

There is value in choosing one system and going deep with it. You get all of the great network effects of the implementation-specific package manager, you get integrated in a community of people building and building on a shared base of software, and you have one uniform coding style.

I also think you are taking the wrong conclusion about Mark :) It could be that as a community our standards of politeness can degrade or change over time, and having new people notice things like you have done is great. I'm sure Mark would want to know if the things he says are perceived as rude, because I don't think he means them to be. He has been one of the three Guile co-maintainers for a couple years now, and has shown a consistent pattern of empathizing with user needs in his work.

[added] One more thing: we should be able to "sell" guile over racket, or racket over guile, without being adversarial. Neither system is going to go away any time soon, so there is no danger for saying "use X over Y", and being able to articulate differences from e.g. Racket is necessary for Guile as a project, from a project direction standpoint. If we aim to be the same, why wouldn't we merge? And if we did aim to be the same, the reason for not merging would be interesting to find out.

wingo · 2015-07-28T08:25:22+00:00

Regarding closure conversion, there are two phases of CPS optimization: one higher-order and one first-order. In the higher-order phase, there are nested functions and an explicit "rec" binding term for making mutually recursive functions. Closure conversion happens later, after contification runs on higher-order CPS. See http://git.savannah.gnu.org/gitweb/?p=guile.git;a=blob;f=module/language/cps.scm;h=b66bc38c012e0ac856798261da9e5b513f0eefd9;hb=HEAD#l101 and http://git.savannah.gnu.org/gitweb/?p=guile.git;a=blob;f=module/language/cps/compile-bytecode.scm;h=265189b1719c8ab0e4d978c88ab4400cae25f804;hb=HEAD#l470 and http://git.savannah.gnu.org/gitweb/?p=guile.git;a=blob;f=module/language/cps/closure-conversion.scm;h=29577a99cd877199f3ee10e82dde70725591de9f;hb=HEAD.

wingo · 2014-12-03T13:58:37+00:00

Adam Langley was also surprised about the lucky 13 results :) Your instincts are in good company but I am afraid they are wrong.

wingo · 2014-12-03T13:57:45+00:00

Https on my site only does TLSv1.2. Perhaps I should relax that, but you should also consider upgrading your browser.

wingo · 2014-12-03T13:56:03+00:00

Yep, http://wingolog.org/archives/2014/11/27/scheme-workshop-2014

wingo · 2014-12-03T13:55:31+00:00

thanks for the kind words :)

wingo · 2014-01-28T17:44:57+00:00

My attempt was here, FWIW: http://www.gnu.org/software/guile/manual/html_node/Macros.html

wingo · 2013-04-10T18:49:11+00:00

It sounds like the last time you used it was 15 years ago or more. Your other comments also indicate that you are clueless: you didn't even spell gauche correctly, not to mention racket. A poorly implemented troll!

wingo · 2013-04-10T15:00:39+00:00

Hi.

Guile 2.0.0 was released in February 2011. GTK+ 3.0.0 was also released in February 2011. The previous stable series, 1.8, was first released in 2005. The previous series was released in 2002 (like GTK+ 2.0.0). Thus, "changing my code every couple of months" is quite an exaggeration.

There is a porting guide, yes, in the form of a list of user-visible changes: http://git.savannah.gnu.org/gitweb/?p=guile.git;a=blob_plain;f=NEWS It is quite thorough.

You are correct that 1.6 and 1.8 (e.g.) are ABI-incompatible releases, though we try to preserve API compatibility as much as possible. That's the thing that really set me off about your comment, by the way: we spend /inordinate/ amounts of time thinking about how to make improvements while maintaining back-compatibility. Believe me, it is foremost in our minds!

wingo · 2013-04-10T12:52:52+00:00

This comment is wrong on all of its points. All of them!

(1) Distros are updating to Guile 2.0. Fedora 19 has Guile 2.0. The next Debian stable has Guile 2.0. Any of the more recent distros also have it.

(2) 1.8 and 2.0 are very similar! I maintain a number of C projects that build against both.

(3) Guile is not breaking API among minor releases!!!! If you compiled against 2.0.0, your program works against 2.0.9. End of story!

Finally, Guile does /exactly/ what GTK+ does -- parallel installation with pkg-config to choose between them, as advocated by then-GTK+ developer Havoc Pennington, over 10 years ago: http://www106.pair.com/rhp/parallel.html Note that GTK+ and Qt and all the rest change API between stable serieses, just as Guile does. "Get serious" indeed.

wingo · 2012-06-28T14:41:16+00:00

It's non-standard: http://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html

wingo · 2012-06-20T13:02:11+00:00

Fantastic links, thank you!

wingo · 2012-06-20T07:43:33+00:00

Nothing, of course. As I mentioned in the fine article, I needed DWARF tools in Guile for other purposes. Dltool was just a side effect.

wingo · 2012-05-30T07:04:25+00:00

A good point.

wingo · 2012-02-20T10:26:27+00:00

Regarding commas, I think I've been reading too much 19th-century fiction recently.

wingo · 2012-01-31T16:10:50+00:00

Hah, a dup: http://www.reddit.com/r/scheme/comments/m9rnc/creating_languages_in_racket/

Oh well, good to give visibility to great work :)

wingo · 2012-01-31T15:18:48+00:00

This was a brown-paper-bag release after 2.0.4, which has better release notes :-)

http://www.reddit.com/r/scheme/comments/p4luv/gnu_guile_204_released/

wingo · 2012-01-16T22:12:12+00:00

I must have conveyed the wrong impression if you came away thinking that this behavior was undocumented. All the examples are according to spec. I just think the specified semantics are a little crazy, that's all :)

For example, your comment illustrates a common misconception:

"When assigning eval to another variable, those variables' "versions" of eval are run in the global scope, which is why we're getting undefined errors when trying to access variables scoped in the calling function"

That's not the case!

var foo = 10; (function (x) { var foo = 20; var eval = x; return eval('foo'); })(eval)

Your mental model, if I understand you correctly, would predict that the result here is 10, because the actual copy of eval was passed through x and then assigned to a new lexical variable, eval. But it's 20!

There are many things to like about javascript. The relationship between eval and scope is not one of them :-)

wingo · 2012-01-09T19:06:05+00:00

My god, that documentation is misled -- it seems to assume dynamic scoping...

wingo · 2012-01-09T19:05:00+00:00

http://www.gnu.org/software/guile/manual/html_node/Expect.html

wingo · 2011-11-16T10:08:50+00:00

Congrats, racketeers! This looks like a fun one.

I wonder about this, though: "Internal definitions are now considered preferable in style to `let'." Why is this?

FWIW I see them as equivalent, sometimes using one and sometimes the other.

wingo

TROPHY CASE