IRC channel logs


back to list of logs

<davexunit>good evening, guilers
<nalaginrut>morning guilers~
*nalaginrut come back to hack after a long vacation
<dsmith>Hej hej
<civodul>Hello Guilers!
<ArneBab_>moint civodul
<wingo>moin :)
<nalaginrut>I have a puzzled question: is Scheme strongly typed? My understanding is strongly-dynamic typed (but after reading some refs online, I'm so confused)
<wingo>the terms are confusing :)
<wingo>what people usually mean these days by "strongly typed" is "has a strong type system", which is not the case for scheme
<wingo>scheme's values have types, but type systems are all about typing parts of the program in order to express certain properties about the program
<ArneBab_>what does “strong type system” mean?
<wingo>and scheme doesn't have a facility on that level
<ArneBab_>wingo: ah, so “declare type before initializing”
<wingo>ArneBab_: parametric polymorphism, algebraic types, etc -- like what haskell or ml give you
<ArneBab_>I did not yet use these, so I’m a bit in the dark here… but I can google them :) — thanks!
<wingo>so "strongly typed" is not a phrase that i personally use to describe scheme -- but since the phrase means different things to different people, it's tough to know what someone else means
<nalaginrut>hah, thanks for explain ;-)
<nalaginrut>will “declare type before initializing” bring some efficient advantages?
<wingo>efficiency is an entirely different question :)
<nalaginrut>ah~so many confused terms
<wingo>a language like javascript doesn't really have a type system, but gets very efficient code by JIT compilation
<wingo>because it can see the concrete types that are in use in hot parts of your program
<wingo>so it has lots of type information -- but that information doesn't come from the type system
<wingo>it's true though that giving variables types in a program can help a compiler to make some of those same decisions that a JIT compiler would make
<wingo>but incrementally adding a type system to e.g. scheme doesn't necessarily speed things up
<wingo>it can, with good compiler integration
<wingo>but without that it's more likely to slow things down, because when you pass values from a untyped part of your program to an typed part of the program you have to add extra assertions
<wingo>the value of types is more on the side of expressiveness than efficiency
<nalaginrut>thanks! now much clear
<wingo>it's also useful to separate types and representations
<wingo>so e.g. (+ x y)
<wingo>you know the types of x and y are "number"
<wingo>because + operates on numbers
<wingo>but they could have many different representations: fixnum, bignum, etc
<nalaginrut>is it better to overload the method for each representations?
<wingo>merely specifying that + operates on numbers doesn't give you a magic way to make + fast
<wingo>because at runtime you still have to check which representations the arguments have
<wingo>nalaginrut: on a level of expressiveness, no :)
<wingo>on efficiency it's not clear; there are a number of possible implementation strategies for +
<wingo>i think at some point we'll add a little inline cache implementation for math operations on values of unknown representation
<wingo>so the runtime would generate a specialized "+" for each instance of "+" in your program :)
<ArneBab_>wingo: matching types sounds interesting - it seems to use types as a kind of limited class-system which can be checked for validity
<nalaginrut>sounds nice!
<nalaginrut>but our class-of is slow to check each possible type, maybe it's a generic way for all languages, dunno ;-)
<nalaginrut>seems the advantages of JIT is far beyond all my expectation ;-P
<wingo>you would be amazed...
<wingo>but aot first :)
<nalaginrut>last year, AOT give me the same amazing...
<nalaginrut>there's always nice hope in the future huh?
<wingo>yep :)
<wingo>and always a lot of work in the present :)
<civodul>wingo: i'm preparing a Hop talk for work, with a demo similar in spirit to Peeple
<civodul>but with JS
<wingo>neat :)
<civodul>that's fun :-)
<nalaginrut>seems the inner server doesn't close port when client closed the connection, POLLRDHUP, dunno, I didn't check the latest Guile
<nalaginrut>(under keep-alive situation)
<nalaginrut>now that POLLRDHUP was introduced by GNU specific, I'm not sure if it's proper to call it a bug
<stis>tja ba guilers!
<ijp>hmm, do we not do any dead code elimination
<ijp>,optimize (and (pair? arg) #f) $8 = (begin (pair? arg) #f)
<mistym>Is the bug-report mailing list working okay? I had a user who was trying to submit a bug, but had their email bounced back.
<ijp>obviously arg may have side effects, but I thought it was weird that pair? hung around
<ijp>mistym: what address are you using?
<ijp>sneek: bugs
<sneek>I could be wrong, but bugs is send reports to, and see bug reports at
<mistym>ijp: They were using bug-guile, I believe
<ijp>well, I sent an email to it just yesterday, and am about to again in a moment
<ijp>so I guess we'll find out then
<mistym>Thanks, let me know if it works.
<ijp>hmm, I just sent it, but I realise now this was a terrible test, because I'm not using that address but a bug specific one :/
<ijp>but maybe I'll find a new bug in the next five minutes :)
***cbot is now known as Guest19018
<dsmith>sneek, bugs?
<sneek>I've heard bugs is send reports to, and see bug reports at
<dsmith>sneek, bugs?
<sneek>I could be wrong, but bugs is send reports to, and see bug reports at
<dsmith>good. Only one
<mistym>dsmith: Bot?
<dsmith>Whoo. more than 2^5 guilers in here
<dsmith>mistym, yes
<dsmith>I did mean 2^6
<ijp>I thought you were on holiday?
<dsmith>THat's dsmith-work
<dsmith>He seems to be offline at the moment..
<mark_weaver>ijp: we do some dead code elimination, but the compiler doesn't know that 'pair?' is effect-free, it seems.
***ozzloy_ is now known as ozzloy
<add^_>Hey dsmith :-)
<add^_>I thought you were on vacation :-P
<dsmith>Yep. No dsmith-work in here!
<dsmith>Seventy guilers are in the channel. Seventy guilers are here! If wingo take ops and kicks one off, sixty-line guilers are in the channel.....
<add^_>A new version of 99 bottles of beer on the wall?
<ijp>looks like wingo was the first to go
<add^_>That was a bit weird.
***mistym is now known as mistym_lunch
<stis>Ahh, finally made guile-log doc's up to date with what's in the repo modulo prolog that is
***mistym_lunch is now known as mistym