2003-07-29.txt:18:43:57: <Taaus> Heh... Well... That's the problem... People have different views of what 'pragmatic' entails ;)
2003-07-30.txt:00:25:16: <Taaus> #  Proper Tail Recursion
2003-09-04.txt:02:15:58: <Verbed> I've worked on a few pieces, all completely synthesized. I imagine the transition from analog to digital difficult, just curious of the details.
2004-05-01.txt:08:57:12: <lament> i doubt anybody ever looked at dis in detail
2004-05-25.txt:19:50:04: <calamari-> basic is good to find out if you can actually program, asm lets you understand the details, c is a standard
2004-05-31.txt:23:57:17: <kosmikus> which part of my original question should I explain in more detail?
2004-06-11.txt:04:16:56: <calamari_> I was thinking about the c compiler.. a valid way to do it is c -> asm, then asm -> binary (bf).  That would actually be pretty neat, because then the c compiler doesn't have to worry about many details
2004-06-28.txt:03:22:08: <WildHalcyon__> fleshing out some bloody annoying details
2004-07-02.txt:06:35:35: <WildHalcyon> The program itself might know where it is - I haven't really fleshed out these particular details yet
2004-07-02.txt:06:43:01: <heatsink> Have you worked out the details?
2004-07-08.txt:17:05:33: <calamari_> I don't know much about the details of tcp/ip
2004-07-17.txt:22:19:52: <Taaus> Just throw a perfect sphere. That's a d1 too. Or get a coin with two heads (or tails).
2004-07-20.txt:22:21:30: <calamari_> I haven't figured out all the details yet
2004-10-31.txt:19:10:13: <lindi-> (just a sec, i'll give the details)
2005-03-06.txt:08:21:15: <cpressey> still a lot of details to work out :)
2005-03-14.txt:19:25:59: <{^Raven^}> i am working from the original code too, making a detailed log of all the changes so far to make it easier for someone to integrate
2005-03-15.txt:16:03:36: <calamari> the way to do that is to have Java check out which class files are in a certain subdirectory, and load them.  Each class can return certain information to plug into the compiler.  Haven't figured out all the details of that yet.. easy for things like GOTO, but assign is harder since  =  isn't at the front
2005-04-06.txt:11:48:33: <Keymaker> like some place where would be detailed info from those languages
2005-04-14.txt:23:26:04: <fizzie> The language probably doesn't. I'm not awake enough to read all the details.
2005-05-04.txt:19:59:21: <fizzie> I don't remember anything really befungey about blank, but I have to admit I don't remember any details about the language.
2005-05-06.txt:20:31:46: <pgimeno> I don't know the details but I remember a few aspects, yeah...
2005-05-10.txt:21:41:46: <pgimeno> well, I'm also working in some subtle I/O details... you know, I don't want this spec to be imprecise or incomplete like that of HQ9+ which lacks a specification of the initial accumulator's value
2005-05-12.txt:21:10:09: <pgimeno> some details have still to be pinned down but it's there already
2005-05-13.txt:14:25:54: <Keymaker> http://www.moviesonline.ca/movie_details.php?id=105
2005-05-15.txt:04:43:27: <calamari> there are never any details, but I take it to be highly difficult to program in and somewhat powerful in its abilities
2005-05-21.txt:21:46:29: <Keymaker> for once a detailed esoteric language manual..
2005-05-26.txt:00:20:43: <pgimeno> http://www.rgagnon.com/jsdetails/js-0034.html
2005-05-27.txt:00:26:48: <graue> kipple: I intended the articles to be like those on Wikipedia, overviews of the languages, with links to detailed examples, programs, and implementations in other places
2005-05-27.txt:04:46:06: <graue> Transmitting file data ....................svn: Commit failed (details follow):
2005-06-04.txt:07:43:55: <graue> news flash: sort language gets name, nice website, faux-academic paper! details @ http://www.oceanbase.org/graue/sortle/
2005-06-04.txt:21:06:50: <pgimeno> I don't remember the details nor where I read about that
2005-06-04.txt:22:28:53: <pgimeno> graue: the intention is to have a more or less detailed description of each language, not just a quick overview like now, right?
2005-06-04.txt:22:30:59: <pgimeno> graue but it would be good to create the sensation that the intention is detailed descriptions, and without the stub notice it seems like they're more or less complete
2005-06-06.txt:09:51:50: <graue> in the twelve-tone system, you take all 12 notes of the chromatic scale, shuffle them into a random permutation, and then add registral details by assigning them to different octaves and such
2005-06-08.txt:05:26:13: <graue> i missed that detail
2005-06-08.txt:05:34:26: <lament> there's a fairly detailed explanation of the program on http://www.dangermouse.net/esoteric/piet.html
2005-06-11.txt:20:28:55: <lament> very little actual detail in that article
2005-06-11.txt:22:52:41: <Keymaker> if i do detailed work i may add it to my site as well
2005-06-12.txt:00:04:22: <GregorR> How much detail do I want to describe this in ...
2005-06-16.txt:01:01:56: <cpressey_> (why do i have a tail all of a sudden...?)
2005-06-22.txt:22:56:15: <jix> because i'm starting the "server" manually using netcat and tail -f ^^
2005-06-24.txt:23:46:51: <calamari> size, whether source or binary in nature.  The internal details or methods
2005-06-25.txt:19:27:22: <calamari> of course there are all the fine details that go along with getting it right, but that's the basic idea of how it works
2005-06-26.txt:22:59:10: <lindi-> calamari: esoshell had some nice gems, like this one: https://savannah.gnu.org/bugs/?func=detailitem&item_id=13254
2005-07-18.txt:18:14:24: <calamari> s from memory, so sorry if there are wrong details
2005-07-26.txt:13:12:13: <pgimeno> like, someone too worried about the details
2005-07-27.txt:11:25:06: <Gs30ng> i got an interesting idea to make this language turing complete, but it needs a time to be embodied in detail
2005-07-27.txt:23:49:28: <graue> how about cocktail shaker sort?
2005-07-27.txt:23:49:38: <graue> http://en.wikipedia.org/wiki/Cocktail_sort
2005-07-27.txt:23:49:39: <jix> cocktail shaker sort?
2005-07-29.txt:00:10:32: <int-e> hmm. that's an infinite loop if your compiler does tail call elimination ...
2005-08-04.txt:07:30:26: <GregorR> And I'm only going because I managed to get a free pass, they retail in the 1000s.
2005-08-05.txt:22:18:43: <calamari> thanks a lot for explaining this in detail 
2005-08-11.txt:00:43:20: <kipple> anyway, lets not go into implementation details at this point :)
2005-08-13.txt:00:13:31: <calamari_> listening to some old mods while I work out the details of my adventure game
2005-08-17.txt:00:12:07: <WildHalcyon> Might be a good idea. I haven't really started any details until I finish the spec...
2005-08-18.txt:06:45:08: <WildHalcyon> It mostly deals with how the implementation details would effect the project, but hopefully you can see where I am going with this.
2005-08-23.txt:05:08:32: <int-e> it's a queue. the circularity is an implementation detail. right.
2005-08-25.txt:19:47:55: <Aardwolf> anyone ever saw this? http://en.wikipedia.org/wiki/Wikipedia:Votes_for_deletion/Esoteric_programming_language_related/Detail
2005-09-04.txt:19:59:36: <jix> the easiest wavelet transformation is..(Haar wavelet a bit simplified) take 2 samples calculate the arithmetic-mean and the difference store the mean into the average signal the difference in the detail signal 
2005-09-16.txt:23:00:52: <Arrogant> I should add tailcall recursion
2005-09-17.txt:23:03:20: <Wildhalcyon> It details some of the effects on programming language mechanics in digital organisms
2005-09-19.txt:18:02:14: <Wildhalcyon> The fact that sometimes it enqueues its head onto its tail is... crazy
2005-09-19.txt:18:02:59: <Wildhalcyon> I think I'll nickname the stack-list monstrosity as "ouroborous" (sp?) since it eats its own tail
2005-09-22.txt:00:57:45: <GregorR> RealSoda has retailers all over the USA it turns out :-P
2005-09-22.txt:01:37:02: <Wildhalcyon> Im trying to read this paper concerning my esolang, but I honestly can't make heads or tails of it. They use (and fail to explain) a lot of terminology, and wikipedia is only helping so much
2005-09-22.txt:04:59:27: <Wildhalcyon> Good point kipple. He's told us that it exists, but withheld other details
2005-09-23.txt:02:12:47: <{^Raven^}> (and most retailers don't even know what they are anyways...like software density select floppy drives)
2005-09-27.txt:21:45:47: <twobitsprite> it would be like tail recursion
2005-09-28.txt:00:52:07: <kipple> no need to clutter the spec with such details. leave it to the implementation
2005-10-01.txt:10:04:23: <Keymaker> (note to everyone: i just updated ibfc page with a missing detail; the divisor is never larger than the dividend in this competition)
2005-10-12.txt:07:23:21: <Gs30ng_> in detail, there could be several ways of music source code
2005-10-14.txt:19:39:31: <wildhalcyon> right, but that still entails looking at the command line crap. I hate all that...
2005-10-22.txt:06:22:39: <lament> !["heads"]["tails"]CHOOSE;!
2005-10-22.txt:06:24:52: <lament> !["heads"]["tails"]#;!
2005-10-22.txt:06:24:59: <lament> !["heads"]["tails"]
2005-10-22.txt:06:28:13: <lament> !["heads"]["tails"]CHOOSE;!
2005-10-22.txt:06:28:35: <lament> !["heads"]["tails"]CHOOSE;!
2005-10-22.txt:06:29:14: <lament> !["heads"]["tails"]CHOOSE;!
2005-10-22.txt:06:29:48: <lament> !["heads"]["tails"]CHOOSE;!
2005-10-22.txt:06:30:00: <lament> !["heads"]["tails"]CHOOSE;!.
2005-10-22.txt:06:33:33: <lament> !["heads"]["tails"]CHOOSE;!
2005-10-22.txt:06:43:12: <lament> !["heads"]["tails"]CHOOSE;!.
2005-10-22.txt:06:43:15: <lament> !["heads"]["tails"]CHOOSE;!
2005-10-22.txt:06:48:16: <lament> !["heads"]["tails"]CHOOSE;!
2005-10-22.txt:06:48:17: <falsebot> tails
2005-10-22.txt:06:48:18: <lament> !["heads"]["tails"]CHOOSE;!
2005-10-22.txt:06:48:18: <falsebot> tails
2005-10-22.txt:06:48:19: <lament> !["heads"]["tails"]CHOOSE;!
2005-10-22.txt:06:48:19: <falsebot> tails
2005-10-22.txt:06:48:20: <lament> !["heads"]["tails"]CHOOSE;!
2005-10-22.txt:06:48:20: <falsebot> tails
2005-10-22.txt:06:48:23: <lament> !["heads"]["tails"]CHOOSE;!
2005-10-22.txt:06:48:25: <lament> !["heads"]["tails"]CHOOSE;!
2005-10-22.txt:06:48:25: <falsebot> tails
2005-10-22.txt:06:48:28: <lament> !["heads"]["tails"]CHOOSE;!
2005-10-22.txt:06:48:28: <falsebot> tails
2005-10-22.txt:06:48:49: <lament> with this seed, the first few hits are much more likely to be tails (odd)
2005-10-22.txt:06:49:08: <lament> ![["heads"]["tails"]CHOOSE;!]HT:
2005-10-22.txt:06:49:15: <falsebot> tails
2005-10-22.txt:06:58:35: <lament> ![["heads"]["tails"]2CHOOSE;!]HT:
2005-10-23.txt:20:52:04: <cpressey> lament: python doesn't to tail calls, and iirc its lambdas are limited to something like one line of code?
2005-10-23.txt:21:13:22: <lament> i don't remember the details
2005-10-23.txt:22:26:13: <GregorR> "It means that it is not detailed enougg" -> "This means that it is not detailed enough"
2005-10-25.txt:20:55:54: <GregorR-L> http://www.amazon.com/exec/obidos/tg/detail/-/0520239490/qid=1130270115/sr=1-1/ref=sr_1_1/102-2026037-5911307?v=glance&s=books < awesome book
2005-10-29.txt:00:43:12: <calamari> GregorR: I don't want to know those kind of digit details ;)
2005-11-01.txt:05:46:37: <lament> i have a tail because of second hand smoke
2005-11-04.txt:06:05:51: <Arrogant> Too bad most languages suck at tail-calling
2005-11-04.txt:07:09:41: <Blonde_19> Damn, wasn't paying attn to detail.
2005-11-05.txt:21:37:17: <calamari> jix: wrapping up the last few details
2005-11-12.txt:19:57:32: <Keymaker> just to add, dbc once explained me in very great detail how his random generator program works.. and gotta say it is a H-A-C-K!!
2005-11-14.txt:04:41:11: <GregorR> I haven't taken a detailed look, but as LORD OF OO ESOLANGS I will.
2005-11-15.txt:00:15:55: <cpressey> well... ok, i guess there sort of is, in the weak sense that all context-free languages are equivalent to balanced parentheses... if you ignore the details... but that's sort of unsatisfying
2005-11-22.txt:01:04:01: <fizzie> This software comes with NO WARRANTY: see the file PUBLIC for details.
2005-11-24.txt:12:29:28: <fizzie> /home/fis/prog/java/jogl/make/build.xml:635: Compile failed; see the compiler error output for details.
2005-12-14.txt:09:49:41: <handongseong> http://www.gsretail.com/GS25/main.asp
2005-12-20.txt:15:28:48: <Gs30ng> fibs = 0 : 1 : [ a+b | a <- fibs | b <- tail fibs ]
2006-01-18.txt:22:24:31: <fizzie> If a coin lands tails up in the forest, does anyone care? 
2006-01-18.txt:23:20:13: * {^Raven^} considers that manything further would be going into too much personal detail
2006-02-04.txt:05:57:17: <calamari> this is a detail
2006-02-04.txt:06:47:43: <calamari> I think I understand the basics of it ok, just missed out on the yummy details
2006-02-18.txt:03:01:18: <graue> i.e., compiler makes functions tail recursive for you
2006-02-25.txt:13:59:00: <ihope> The details are sorta weird.
2006-03-10.txt:21:18:21: <ihope> See http://en.wikipedia.org/wiki/Wikipedia:Copyrights for details.
2006-03-29.txt:07:25:40: <nooga> 'a' with tail
2006-05-26.txt:06:52:55: <GregorR> Sans-detail, sans-readability, sans-aesthetics.
2006-05-29.txt:16:29:50: <wildhalcyon> I'm working out the details, but its moving away from bf
2006-06-13.txt:16:13:47: <SimonRC> not if you made a tail-call...
2006-06-13.txt:16:14:23: <SimonRC> never return, you can tail-call
2006-07-11.txt:22:09:58: <ihope> "A list is the empty list or both a head and a tail." <- a type declaration in English.
2006-07-11.txt:22:12:34: <ihope> "The length of the empty list is 0. The length of a list is 1 + the length of the tail of the list." <- a function declaration in English.
2006-08-02.txt:22:42:29: <RodgerTheGreat> tail-recursion?
2006-08-02.txt:23:06:28: <pikhq> Mmm. Found a Tcl package which allows for, among other things, tail call optimisation.
2006-08-08.txt:16:41:39: <RodgerTheGreat> what does the Zlib license entail?
2006-08-12.txt:00:15:47: <nooga> details
2006-08-20.txt:01:54:42: <RodgerTheGreat> mmm. tail recursion.
2006-08-22.txt:17:42:43: <RodgerTheGreat> the general rule is simply that you need to include in your submission any details/etc that we'll need to use it.
2006-08-22.txt:22:35:24: <lament> CakeProphet: A cons cell consists of a head and a tail, both of which could contain anything
2006-08-22.txt:22:35:43: <lament> 1 is the head, 2 is the tail
2006-08-22.txt:22:36:17: <lament> now we can put another cons cell in the tail
2006-08-22.txt:22:36:41: <lament> 1 is the head, (2 3) is the tail
2006-08-22.txt:22:36:55: <lament> 1 is the head, (2 (3 4)) is the tail
2006-08-22.txt:22:38:12: <lament> by putting some object in the 'head' section and the remainder of the list in the 'tail'
2006-08-22.txt:22:38:34: <lament> eg for a list of integers, the head of each cell is an integer, and the tail is a list.
2006-08-23.txt:18:48:02: <ihope_> And I see that this Python thingamahoochie doesn't like tail recursion.
2006-08-23.txt:18:49:46: <ihope_> Where am I supposed to get my daily fix of tail recursion?
2006-08-23.txt:18:51:16: <fizzie> Where the Spec promises you proper tail recursion.
2006-08-24.txt:00:54:22: <lament> i thought we went through all this in detail when we were discussing Banana Scheem.
2006-08-25.txt:22:34:32: <RodgerTheGreat> and then I get to savor sweet freedom (whilst, in theory, being forced to do oodles of homework. piddling details.)
2006-08-29.txt:01:21:54: <Razor-X> The only one thing I think Scheme can use is Haskell and OCaML's built-in head-tail things.
2006-08-29.txt:01:22:14: <Razor-X> Instead of binding head and tail via let, pattern matching is actually pretty nifty.
2006-08-29.txt:01:23:22: <GreyKnight> Razor-X: what's this pattern-matching head/tail of which you speak?
2006-08-29.txt:01:24:18: <Razor-X> GreyKnight: In Haskell, you can write a function parameter as a cons'd list. So the head of the list will automatically be assigned to what you assign at its head, and the tail automatically as what you design the tail to be.
2006-08-29.txt:03:23:23: <pikhq> (also an unpleasent thing about Tcl (although Tcl handles it better *AND* there's a package in Tcllib to do tail call optimisation, so you shouldn't run into it if you're sane))
2006-08-29.txt:04:00:51: <GreyKnight> Basically the premise of the legend books is that every single technological and social detail of the Empire was established at the time of the Jihad, 10 millenia ago
2006-08-29.txt:19:11:00: <ihope> lamentLikes x = length x == 6 && head x == 'P' && head (tail x) == 'y' && head (tail (tail x)) == 't' && head (tail (tail (tail x))) = 'h' && head (tail (tail (tail (tail x)))) = 'o' && head (tail (tail (tail (tail (tail x))))) = 'n'
2006-09-02.txt:03:23:24: <GreyPaladin> I find if you give the eta a slightly hooked tail, it helps
2006-09-02.txt:03:23:48: <Razor-X> I make the curve start very high and make the right tail extend lower.
2006-09-02.txt:03:24:40: <GreyPaladin> well, obviously this was in very fast-handwritten text, so the tails sometimes "shrank" as the author went along... still, worth thinking about if you plan to write some sort of guide
2006-09-03.txt:23:40:22: <pikhq> Razor-X: You've got one convenient thing for this: I've already described, in much detail, the compilation of one example. . . ;)
2006-09-04.txt:03:22:44: <GreyKnight> the top hook and the tail should be pretty prominent
2006-09-04.txt:10:30:28: <fizzie> There's the implementation list at http://community.schemewiki.org/?scheme-faq-standards#implementations but it has no details, so going through it is quite a chore.
2006-09-08.txt:03:14:46: <Razor-X> I doubt they'd introduce little mindless CS acolytes to the concepts of functional languages either (except some tail-recursion).
2006-09-11.txt:03:17:18: <sparr_> i have been using applicators directly, but the level of control and detail is quite lacking
2006-09-16.txt:21:47:54: <lindi-> Razor-X: if you know C++ i can give you all the details to the bug and you can try to hunt it down ;) i've spent days
2006-09-24.txt:19:16:46: <SimonRC> give details
2006-10-06.txt:00:27:40: <pikhq> Allow me to specify in more detail. . .
2006-10-09.txt:03:58:59: <dbc> About cell clearing...I'm not familiar with details of your thing, but when I looked at BFBASIC I noticed that it cleared all cells immediately before use...and that if it cleared all cells that might be nonzero immediately AFTER use, it would have produced shorter code...
2006-10-14.txt:22:28:15: <Razor-X> We only have basic theoretical sciences, AP theoretical sciences, and a bit by the way of biology where you get to learn in detail how animals poop, mate, sleep, eat, and continue this circle ad-infinitum.
2006-10-18.txt:02:52:27: <Sgeo> I need more details though
2006-10-21.txt:21:05:44: <Razor-X> But it uses recursion, and I'm not using tail recursion here.
2006-10-23.txt:06:57:38: <RodgerTheGreat> well, good night... er... good morning. I'd be fascinated to discuss this in more detail later.
2006-10-23.txt:22:05:03: <Asztal> Do people just submit statements, not knowing any details of the rest of the language?
2006-10-29.txt:08:49:53: <thematrixeatsyou> . = wire, + = tail, * = electron
2006-11-02.txt:21:20:38: <RodgerTheGreat> storage is not limited by the spec or the language's implicit details, so it is a turing-complete language
2006-11-03.txt:19:22:59: <SimonRC> detail (v.)
2006-11-17.txt:00:54:15: <xor_> But tail recursion a la scheme is ugly too
2006-11-17.txt:00:56:01: <Razor-X> Tail recursion is made effecient.
2006-11-17.txt:00:56:19: <Razor-X> Almost all of Lisp's idioms encourage the use of tail recursion. Haskell does too.
2006-11-17.txt:02:55:53: <xor_> Please support your awnser with a detailed explaination
2006-11-22.txt:01:50:35: <RodgerTheGreat> program specifications in English are effectively equivalent to sourcecode if they're detailed, they just need an extremely complex compiler (a human) to convert.
2006-11-26.txt:04:17:27: <GreaseMonkey> 1 = electron -> tail (2)
2006-11-26.txt:04:17:34: <GreaseMonkey> 2 = tail -> wire (3)
2006-11-26.txt:04:18:02: <RodgerTheGreat> if you think of wire as traversible space and electron heads and tails as particles, it's pretty easy to see it as a particle automaton, although cellular automaton is equally valid
2006-11-27.txt:06:33:57: <Razor-X> Mmmf. GreaseMonkey: Explain your architecture in a bit of detail.
2006-12-02.txt:04:03:12: <Razor-X> One of the main reasons DO is not used in Scheme very often is because the syntax is longer to remember than tail recursion. Of course, tail recursion pays the price of computing effeciency until you learn the streams abstraction.
2006-12-02.txt:06:00:55: <Razor-X> Tail recursion, rather.
2006-12-02.txt:06:01:17: <twobitsprite> factor has full tail-call optimization
2006-12-02.txt:06:01:17: <Razor-X> It has tail recursion (by way of RECURSE), but it's not used very often.
2006-12-02.txt:06:20:47: <twobitsprite> it's mostly a matter of which language provides the most features which will save you typing and save you from focusing on to many inane details
2006-12-02.txt:19:24:34: <SimonRC> ESR advocates a style he calls "midle-out programming"  where you write the bit sof code that actually *do* stuff, and gradually move the nice setup, teardown, do-multiple-things, etc into layers above, and move the low-level details into layesr below.
2006-12-02.txt:22:41:48: <Razor-X> There's your effecient tail recursion.
2006-12-07.txt:23:05:29: <pgimeno> I already took advantage of a Google translation to find that the basis of Iizawa's method was 'data modules', but I'm interested in the details
2006-12-15.txt:22:00:00: <SimonRC> :-S  http://www.propeller-island.de/rooms_neu/room_detail/23/index.php
2006-12-23.txt:11:46:22: <pgimeno> hm, thinking about it, you also have to track electron tails if you don't want to leave 'stale' trails
2006-12-23.txt:11:48:01: <pgimeno> e.g. when two electrons annihilate each other (as if one of them were a positron) there's a state in which the tails remain
2006-12-28.txt:18:25:24: <pikhq> (look in macro.tcl, proc string, for the gory details)
2006-12-30.txt:20:19:54: <RodgerTheGreat_> advanced looping constructs aren't that vital if we allow normal- and tail-recursion
2006-12-30.txt:20:33:17: <CakeProphet> we can work out syntatical details later.
2006-12-30.txt:21:44:32: <CakeProphet> *shrugs*   nothing detailed... just "sbustition".
2006-12-31.txt:05:12:36: <CakeProphet> yeah... there's a lot of details you can specify in a kernel.
2007-01-02.txt:04:10:47: <oerjan> you might want to adjust run to do proper tail call optimization.
2007-01-02.txt:04:23:35: <CakeProphet> hmmm... to make it do optimization for tail recursion you simply return the call right?
2007-01-07.txt:18:13:01: <SimonRC> see The Repositor Of All Huma Knowlage for more details
2007-01-12.txt:03:54:10: <bsmntbombdood> oerjan: partitition(sep) => (head, sep, tail)
2007-01-14.txt:01:59:20: <oerjan> Note that if it is tail recursive the recursion may be optimized away.
2007-01-14.txt:01:59:57: <bsmntbombdood> tail recursion modulo cons?
2007-01-19.txt:23:40:02: <oklopol> since there would be an infinite series of numbers as the decimal tail
2007-01-21.txt:15:51:42: <oklopol> you can read the server rfc if you care about details :)
2007-02-01.txt:01:31:39: <SimonRC> bsmntbombdood: you mean: "fibbs = 0:1:zipWith (+) fibbs (tail fibbs)"
2007-02-18.txt:22:00:30: <SevenInchBread> well... the entire idea behind OO is that the details of the implementation are hidden behind a name...if everybody assumes that the procedures behind the names all do what they're supposed to do... then everything works fine.
2007-02-18.txt:23:55:30: <oerjan> Make that fibseq = '0' : tail (concatMap s fibseq) where s '0' = "01"; s '1' = "0"
2007-02-22.txt:17:06:03: <ais523> because I haven't figured out the details
2007-02-22.txt:18:46:52: <ais523> http://alexa.com/data/details/traffic_details?url=esolangs.org
2007-02-24.txt:21:52:04: <SimonRC> Boehm GC has a few points of suckitude:  If there is a fake pointer to the head of a list, and that list is continually created at the tail by one routine and destroyed at the head by another, then memory usage will grow indefinitely, as the fake pointer prevents *any* of the list from being collected.
2007-02-24.txt:22:50:47: <oerjan> what about it? not that i know/remember the details, but it is hardly the state of the art.
2007-03-05.txt:03:32:57: <bsmntbombdood> too bad it doesn't optimize tail recursion
2007-03-05.txt:03:35:11: <bsmntbombdood> looks like it optimizes tail recursion!
2007-03-05.txt:03:36:50: <bsmntbombdood> up to a million tail calls...
2007-03-09.txt:16:06:17: <ais523> (Flip a coin. If you flip tails, you win $2. Otherwise, flip again; with tails you get $4, with heads flip again, then you get $8 for tails on the third flip, $16 for tails on the fourth flip, etc.)
2007-03-09.txt:16:06:37: <oerjan> which is a tailor series.
2007-03-16.txt:00:26:31: <oerjan> it's even tail recursive
2007-03-16.txt:21:30:45: <RodgerTheGreat> fortunately, it doesn't break our general solution to the problem, just the details of how it works
2007-03-17.txt:20:58:57: <SevenInchBread> a protocol for defining protocols would be sweet... even though it would basically entail creating an entire programming language and sending it across lines... and it would be the biggest security hazard ever.
2007-03-18.txt:14:18:20: <oklopol> because i like python... but it doesn't use tail recursion (i think) and it isn't lazy
2007-03-21.txt:23:27:21: <lament> that's basically it, the devil's in the details...
2007-03-22.txt:19:10:55: * SevenInchBread is beginning to become  weary of all the strictness entailed in computing...
2007-03-25.txt:00:59:26: <SevenInchBread> neat, detail-oriented, good concentration, organized.     ....I'm the polar opposite of that.
2007-03-25.txt:22:38:00: <oklopol> the only thing you can do in the game is check how well your bot is doing and read details about it's fights... and if you find something you can improve, you either code a new bot or change the code for the old one
2007-03-26.txt:16:33:44: <ais523> however, I don't know any of the details, so it might just be an urban legend
2007-03-26.txt:20:22:04: <lament> there was a joke about that on the esolang list a long time ago. I forgot the details.
2007-03-27.txt:02:22:17: <oerjan> and thereby ruined tail call optimisation
2007-03-28.txt:01:57:02: <Figs> http://www.netscrap.com/netscrap_detail.cfm?scrap_id=85
2007-03-29.txt:18:46:17: <oerjan> let f l = 1 : zipWith (+) l (tail l) in fix f
2007-03-29.txt:18:51:43: <oerjan> let fib = 1 : 1 : zipWith (+) fib (tail fib)
2007-04-02.txt:22:40:18: <CakeProphet_> ...just... a part... with all the vagueness entailed.
2007-04-02.txt:22:52:33: <lament> we can still "explain" them by detailing their behavior
2007-04-08.txt:01:16:49: <Pikhq> GregorR: Describe it; the page doesn't detail much.
2007-04-08.txt:23:50:12: * oerjan is not versed in the details of this.
2007-04-10.txt:02:10:56: <bsmntbombdood> "Broken client, apparently .. not sure the details", "I'm speculating, but usually that reason means it was disconnecting/reconnecting/etc.. or joining/rejoining/etc.."
2007-04-11.txt:02:11:30: <Pikhq> GregorR: Hmm. I need to see some details on the SPS internals. . .
2007-04-11.txt:03:48:49: <Pikhq> See the GCC documentation (under Gcov) for details on how to use it. . .
2007-04-15.txt:22:11:22: <ihope> You have a zero-tailed string of integers, and your two operations are "increment" and "truncate". When the string is truncated, the head will go into a Minsky machine register.
2007-04-17.txt:02:29:38: <SevenInchBread> the kernel provides the low-level details... but rarely will those low-level details be directly called by anything other than a select few processes.   mem will call memory allocation stuff, etc.
2007-04-27.txt:19:35:21: <lament> 39, hasekll: let f=0:1:zipWith(+)f(tail f)in f!!435
2007-04-28.txt:04:31:26: <oerjan> ok unoptimized tail recursion
2007-04-28.txt:05:39:06: <oerjan> if you do something like (cons a (tail b))
2007-04-28.txt:06:10:58: <bsmntbombdood> a pair (pointer to head, pointer to tail)
2007-05-18.txt:08:49:46: <bsmntbombdood> you'd need some detailed code analysis to figure out when it was safe to deallocate a block
2007-05-25.txt:04:02:03: <ihope> Oh, that page details it.
2007-05-27.txt:23:45:44: <SimonRC> bsmntbombdood: give details
2007-05-29.txt:23:27:09: <Pikhq> If your intention is to see the details of how not to do a language, then Java's got some good examples.
2007-06-01.txt:02:51:58: <bsmntbombdood> there's a good talk somewhere that he explains it in detail
2007-06-07.txt:19:34:35: <SimonRC> let { foo = "0" ++ (tail $ concat [if c == '0' then "01" else "10" | c <- foo]) } in foo
2007-06-14.txt:19:37:56: <pikhq> The tape is merely finite, but that's an implementation detail.
2007-06-16.txt:00:50:36: <bsmntbombdood> CPS makes call/cc and tail call optimization very easy
2007-06-16.txt:18:19:19: <RodgerTheGreat> bsmntbombdood: I am aware of a technique that abuses fedex policy and entails duct-tape usage by which you may create a bed for ~$0.
2007-06-18.txt:22:43:35: <SimonRC> or you can use the known details to find a free copy out there on the web, or on the author's webshite
2007-06-23.txt:21:20:25: <RodgerTheGreat> depends on the level of detail you want, and the manner in which we design how the tiles... tile.
2007-06-23.txt:21:20:48: <Sukoshi> Square tiles. GBA detail.
2007-06-25.txt:19:00:42: <RodgerTheGreat> and I'm pretty sure that figure would entail grokking an entire book in about a minute
2007-06-29.txt:03:42:22: <ihope> Does it have details on why it failed?
2007-06-30.txt:19:00:35: <Tritonio> I don't understand a detail.
2007-07-02.txt:09:08:46: <immibis> !factoid alzcwat is you do to a lion zebra crossover with a tail
2007-07-02.txt:09:08:55: <immibis> !factoid alzcwat is a lion/zebra crossover with a tail
2007-07-02.txt:09:09:01: <toBogE> alzcwat is a lion/zebra crossover with a tail
2007-07-03.txt:22:15:12: <lament> oklopol: i don't know the details, if "empty" cells on the tap are encoded by empty GOL patterns, then the initial configuration will be finite
2007-07-04.txt:04:13:38: <lament> like i said, look at forth in more detail
2007-07-04.txt:16:54:53: <oklopol> most people like to think most details in organisms are there because they're optimal
2007-07-04.txt:17:55:59: <Tok-A-Mak> the worldline can be a tiny bit offsetted and some datails might be different from the point of time when you left
2007-07-05.txt:23:00:03: <RodgerTheGreat> yes. In great detail
2007-07-09.txt:05:24:27: <Sukoshi> I'm glad you're not adding graphic detail to that :P
2007-07-09.txt:06:16:22: <fax> you cant store the head, you need to head and head of tail
2007-07-09.txt:06:17:04: <bsmntbombdood> head and tail are stored normally
2007-07-09.txt:06:19:11: <bsmntbombdood> fax: no point in a doubly linked list without storing the tail
2007-07-09.txt:21:42:48: <edwardk> it has tail call optimization
2007-07-11.txt:00:33:11: <bsmntbombdood> Sukoshi: iteration is only tail recursion
2007-07-14.txt:00:22:53: <oklokok> lament: i never remember a name, and i remember details like religion if they are somehow important in the events of the book
2007-07-14.txt:00:25:24: <oklokok> negrophilia is okay on tv, in books you can even tell details about it without even mentioning it in the cover or smth
2007-07-14.txt:00:41:36: <lament> books by serious writers often have detailed commentaries that list and explain all the references
2007-07-14.txt:05:08:09: <RodgerTheGreat> I may conclude with some detailed Applet coding tricks, too, because they can be hard to come by these days
2007-07-14.txt:06:47:33: <pikhq> Using it as a title usually entails the artistry of your work.
2007-07-14.txt:19:57:19: <RodgerTheGreat> the head node and tail node would in theory receive 50% of the experience of the interspersed nodes
2007-07-14.txt:21:22:03: <GregorR-L> Red-tail boa constrictors.
2007-07-14.txt:22:07:43: <RodgerTheGreat> ^ that is a much more detailed description
2007-07-18.txt:06:04:52: <oklokok> i can play the first 32 or so bars now... it just keeps changing the details, hard to remember it all :=)
2007-07-19.txt:16:28:09: <oklokok> stop complaining about details, choosing a representation isn't programming :)
2007-07-20.txt:10:38:24: <fizzie> You should probably provide more information if you want a more detailed answer. The possible reasons for exception are quite different for, say, an InputStreamReader reading a socket than a FileReader.
2007-07-22.txt:22:50:06: <ehird`> tail-recursion optimization? absolutely free!
2007-07-23.txt:19:09:01: <lament> tail-recursively!
2007-07-23.txt:20:59:09: <oklofok> well anyway, it's a few details over that
2007-07-23.txt:22:29:02: <bsmntbombdood> oklofok: that can be made tail recursive easily, i just didn't bother
2007-07-26.txt:23:57:50: <SimonRC> CPS requires that all the continuation calls be tail-calls
2007-07-27.txt:00:07:25: <test_> SimonRC, to take a quote from lazy k, the computation part of coroutines is an implementation detail... so if you imagine "yield" as a branching statement, they are pure
2007-07-27.txt:10:26:55: <RodgerTheGreat> I understand how the machine functions on a systemic level, but there isn't much information on the mechanical details
2007-08-02.txt:21:07:28: <ehird`> i think being more detailed would be much complexity for something that isn't needed
2007-08-10.txt:01:15:52: <ihope> I don't remember the details.
2007-08-12.txt:20:20:48: <ehird`> very detailed colours
2007-08-13.txt:17:57:30: <ehird`> "New NovaDreamer coming soon! Please join mailing list to be notified about details." i wonder how long that has been up
2007-08-14.txt:22:54:54: <ehird`> or have a weird tail-call optimization-implementing interp
[too many lines; stopping]