|
1385
|
1 2003-07-29.txt:18:43:57: <Taaus> Heh... Well... That's the problem... People have different views of what 'pragmatic' entails ;)
|
|
|
2 2003-07-30.txt:00:25:16: <Taaus> # Proper Tail Recursion
|
|
|
3 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.
|
|
|
4 2004-05-01.txt:08:57:12: <lament> i doubt anybody ever looked at dis in detail
|
|
|
5 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
|
|
|
6 2004-05-31.txt:23:57:17: <kosmikus> which part of my original question should I explain in more detail?
|
|
|
7 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
|
|
|
8 2004-06-28.txt:03:22:08: <WildHalcyon__> fleshing out some bloody annoying details
|
|
|
9 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
|
|
|
10 2004-07-02.txt:06:43:01: <heatsink> Have you worked out the details?
|
|
|
11 2004-07-08.txt:17:05:33: <calamari_> I don't know much about the details of tcp/ip
|
|
|
12 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).
|
|
|
13 2004-07-20.txt:22:21:30: <calamari_> I haven't figured out all the details yet
|
|
|
14 2004-10-31.txt:19:10:13: <lindi-> (just a sec, i'll give the details)
|
|
|
15 2005-03-06.txt:08:21:15: <cpressey> still a lot of details to work out :)
|
|
|
16 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
|
|
|
17 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
|
|
|
18 2005-04-06.txt:11:48:33: <Keymaker> like some place where would be detailed info from those languages
|
|
|
19 2005-04-14.txt:23:26:04: <fizzie> The language probably doesn't. I'm not awake enough to read all the details.
|
|
|
20 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.
|
|
|
21 2005-05-06.txt:20:31:46: <pgimeno> I don't know the details but I remember a few aspects, yeah...
|
|
|
22 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
|
|
|
23 2005-05-12.txt:21:10:09: <pgimeno> some details have still to be pinned down but it's there already
|
|
|
24 2005-05-13.txt:14:25:54: <Keymaker> http://www.moviesonline.ca/movie_details.php?id=105
|
|
|
25 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
|
|
|
26 2005-05-21.txt:21:46:29: <Keymaker> for once a detailed esoteric language manual..
|
|
|
27 2005-05-26.txt:00:20:43: <pgimeno> http://www.rgagnon.com/jsdetails/js-0034.html
|
|
|
28 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
|
|
|
29 2005-05-27.txt:04:46:06: <graue> Transmitting file data ....................svn: Commit failed (details follow):
|
|
|
30 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/
|
|
|
31 2005-06-04.txt:21:06:50: <pgimeno> I don't remember the details nor where I read about that
|
|
|
32 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?
|
|
|
33 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
|
|
|
34 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
|
|
|
35 2005-06-08.txt:05:26:13: <graue> i missed that detail
|
|
|
36 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
|
|
|
37 2005-06-11.txt:20:28:55: <lament> very little actual detail in that article
|
|
|
38 2005-06-11.txt:22:52:41: <Keymaker> if i do detailed work i may add it to my site as well
|
|
|
39 2005-06-12.txt:00:04:22: <GregorR> How much detail do I want to describe this in ...
|
|
|
40 2005-06-16.txt:01:01:56: <cpressey_> (why do i have a tail all of a sudden...?)
|
|
|
41 2005-06-22.txt:22:56:15: <jix> because i'm starting the "server" manually using netcat and tail -f ^^
|
|
|
42 2005-06-24.txt:23:46:51: <calamari> size, whether source or binary in nature. The internal details or methods
|
|
|
43 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
|
|
|
44 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
|
|
|
45 2005-07-18.txt:18:14:24: <calamari> s from memory, so sorry if there are wrong details
|
|
|
46 2005-07-26.txt:13:12:13: <pgimeno> like, someone too worried about the details
|
|
|
47 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
|
|
|
48 2005-07-27.txt:23:49:28: <graue> how about cocktail shaker sort?
|
|
|
49 2005-07-27.txt:23:49:38: <graue> http://en.wikipedia.org/wiki/Cocktail_sort
|
|
|
50 2005-07-27.txt:23:49:39: <jix> cocktail shaker sort?
|
|
|
51 2005-07-29.txt:00:10:32: <int-e> hmm. that's an infinite loop if your compiler does tail call elimination ...
|
|
|
52 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.
|
|
|
53 2005-08-05.txt:22:18:43: <calamari> thanks a lot for explaining this in detail
|
|
|
54 2005-08-11.txt:00:43:20: <kipple> anyway, lets not go into implementation details at this point :)
|
|
|
55 2005-08-13.txt:00:13:31: <calamari_> listening to some old mods while I work out the details of my adventure game
|
|
|
56 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...
|
|
|
57 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.
|
|
|
58 2005-08-23.txt:05:08:32: <int-e> it's a queue. the circularity is an implementation detail. right.
|
|
|
59 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
|
|
|
60 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
|
|
|
61 2005-09-16.txt:23:00:52: <Arrogant> I should add tailcall recursion
|
|
|
62 2005-09-17.txt:23:03:20: <Wildhalcyon> It details some of the effects on programming language mechanics in digital organisms
|
|
|
63 2005-09-19.txt:18:02:14: <Wildhalcyon> The fact that sometimes it enqueues its head onto its tail is... crazy
|
|
|
64 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
|
|
|
65 2005-09-22.txt:00:57:45: <GregorR> RealSoda has retailers all over the USA it turns out :-P
|
|
|
66 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
|
|
|
67 2005-09-22.txt:04:59:27: <Wildhalcyon> Good point kipple. He's told us that it exists, but withheld other details
|
|
|
68 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)
|
|
|
69 2005-09-27.txt:21:45:47: <twobitsprite> it would be like tail recursion
|
|
|
70 2005-09-28.txt:00:52:07: <kipple> no need to clutter the spec with such details. leave it to the implementation
|
|
|
71 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)
|
|
|
72 2005-10-12.txt:07:23:21: <Gs30ng_> in detail, there could be several ways of music source code
|
|
|
73 2005-10-14.txt:19:39:31: <wildhalcyon> right, but that still entails looking at the command line crap. I hate all that...
|
|
|
74 2005-10-22.txt:06:22:39: <lament> !["heads"]["tails"]CHOOSE;!
|
|
|
75 2005-10-22.txt:06:24:52: <lament> !["heads"]["tails"]#;!
|
|
|
76 2005-10-22.txt:06:24:59: <lament> !["heads"]["tails"]
|
|
|
77 2005-10-22.txt:06:28:13: <lament> !["heads"]["tails"]CHOOSE;!
|
|
|
78 2005-10-22.txt:06:28:35: <lament> !["heads"]["tails"]CHOOSE;!
|
|
|
79 2005-10-22.txt:06:29:14: <lament> !["heads"]["tails"]CHOOSE;!
|
|
|
80 2005-10-22.txt:06:29:48: <lament> !["heads"]["tails"]CHOOSE;!
|
|
|
81 2005-10-22.txt:06:30:00: <lament> !["heads"]["tails"]CHOOSE;!.
|
|
|
82 2005-10-22.txt:06:33:33: <lament> !["heads"]["tails"]CHOOSE;!
|
|
|
83 2005-10-22.txt:06:43:12: <lament> !["heads"]["tails"]CHOOSE;!.
|
|
|
84 2005-10-22.txt:06:43:15: <lament> !["heads"]["tails"]CHOOSE;!
|
|
|
85 2005-10-22.txt:06:48:16: <lament> !["heads"]["tails"]CHOOSE;!
|
|
|
86 2005-10-22.txt:06:48:17: <falsebot> tails
|
|
|
87 2005-10-22.txt:06:48:18: <lament> !["heads"]["tails"]CHOOSE;!
|
|
|
88 2005-10-22.txt:06:48:18: <falsebot> tails
|
|
|
89 2005-10-22.txt:06:48:19: <lament> !["heads"]["tails"]CHOOSE;!
|
|
|
90 2005-10-22.txt:06:48:19: <falsebot> tails
|
|
|
91 2005-10-22.txt:06:48:20: <lament> !["heads"]["tails"]CHOOSE;!
|
|
|
92 2005-10-22.txt:06:48:20: <falsebot> tails
|
|
|
93 2005-10-22.txt:06:48:23: <lament> !["heads"]["tails"]CHOOSE;!
|
|
|
94 2005-10-22.txt:06:48:25: <lament> !["heads"]["tails"]CHOOSE;!
|
|
|
95 2005-10-22.txt:06:48:25: <falsebot> tails
|
|
|
96 2005-10-22.txt:06:48:28: <lament> !["heads"]["tails"]CHOOSE;!
|
|
|
97 2005-10-22.txt:06:48:28: <falsebot> tails
|
|
|
98 2005-10-22.txt:06:48:49: <lament> with this seed, the first few hits are much more likely to be tails (odd)
|
|
|
99 2005-10-22.txt:06:49:08: <lament> ![["heads"]["tails"]CHOOSE;!]HT:
|
|
|
100 2005-10-22.txt:06:49:15: <falsebot> tails
|
|
|
101 2005-10-22.txt:06:58:35: <lament> ![["heads"]["tails"]2CHOOSE;!]HT:
|
|
|
102 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?
|
|
|
103 2005-10-23.txt:21:13:22: <lament> i don't remember the details
|
|
|
104 2005-10-23.txt:22:26:13: <GregorR> "It means that it is not detailed enougg" -> "This means that it is not detailed enough"
|
|
|
105 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
|
|
|
106 2005-10-29.txt:00:43:12: <calamari> GregorR: I don't want to know those kind of digit details ;)
|
|
|
107 2005-11-01.txt:05:46:37: <lament> i have a tail because of second hand smoke
|
|
|
108 2005-11-04.txt:06:05:51: <Arrogant> Too bad most languages suck at tail-calling
|
|
|
109 2005-11-04.txt:07:09:41: <Blonde_19> Damn, wasn't paying attn to detail.
|
|
|
110 2005-11-05.txt:21:37:17: <calamari> jix: wrapping up the last few details
|
|
|
111 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!!
|
|
|
112 2005-11-14.txt:04:41:11: <GregorR> I haven't taken a detailed look, but as LORD OF OO ESOLANGS I will.
|
|
|
113 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
|
|
|
114 2005-11-22.txt:01:04:01: <fizzie> This software comes with NO WARRANTY: see the file PUBLIC for details.
|
|
|
115 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.
|
|
|
116 2005-12-14.txt:09:49:41: <handongseong> http://www.gsretail.com/GS25/main.asp
|
|
|
117 2005-12-20.txt:15:28:48: <Gs30ng> fibs = 0 : 1 : [ a+b | a <- fibs | b <- tail fibs ]
|
|
|
118 2006-01-18.txt:22:24:31: <fizzie> If a coin lands tails up in the forest, does anyone care?
|
|
|
119 2006-01-18.txt:23:20:13: * {^Raven^} considers that manything further would be going into too much personal detail
|
|
|
120 2006-02-04.txt:05:57:17: <calamari> this is a detail
|
|
|
121 2006-02-04.txt:06:47:43: <calamari> I think I understand the basics of it ok, just missed out on the yummy details
|
|
|
122 2006-02-18.txt:03:01:18: <graue> i.e., compiler makes functions tail recursive for you
|
|
|
123 2006-02-25.txt:13:59:00: <ihope> The details are sorta weird.
|
|
|
124 2006-03-10.txt:21:18:21: <ihope> See http://en.wikipedia.org/wiki/Wikipedia:Copyrights for details.
|
|
|
125 2006-03-29.txt:07:25:40: <nooga> 'a' with tail
|
|
|
126 2006-05-26.txt:06:52:55: <GregorR> Sans-detail, sans-readability, sans-aesthetics.
|
|
|
127 2006-05-29.txt:16:29:50: <wildhalcyon> I'm working out the details, but its moving away from bf
|
|
|
128 2006-06-13.txt:16:13:47: <SimonRC> not if you made a tail-call...
|
|
|
129 2006-06-13.txt:16:14:23: <SimonRC> never return, you can tail-call
|
|
|
130 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.
|
|
|
131 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.
|
|
|
132 2006-08-02.txt:22:42:29: <RodgerTheGreat> tail-recursion?
|
|
|
133 2006-08-02.txt:23:06:28: <pikhq> Mmm. Found a Tcl package which allows for, among other things, tail call optimisation.
|
|
|
134 2006-08-08.txt:16:41:39: <RodgerTheGreat> what does the Zlib license entail?
|
|
|
135 2006-08-12.txt:00:15:47: <nooga> details
|
|
|
136 2006-08-20.txt:01:54:42: <RodgerTheGreat> mmm. tail recursion.
|
|
|
137 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.
|
|
|
138 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
|
|
|
139 2006-08-22.txt:22:35:43: <lament> 1 is the head, 2 is the tail
|
|
|
140 2006-08-22.txt:22:36:17: <lament> now we can put another cons cell in the tail
|
|
|
141 2006-08-22.txt:22:36:41: <lament> 1 is the head, (2 3) is the tail
|
|
|
142 2006-08-22.txt:22:36:55: <lament> 1 is the head, (2 (3 4)) is the tail
|
|
|
143 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'
|
|
|
144 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.
|
|
|
145 2006-08-23.txt:18:48:02: <ihope_> And I see that this Python thingamahoochie doesn't like tail recursion.
|
|
|
146 2006-08-23.txt:18:49:46: <ihope_> Where am I supposed to get my daily fix of tail recursion?
|
|
|
147 2006-08-23.txt:18:51:16: <fizzie> Where the Spec promises you proper tail recursion.
|
|
|
148 2006-08-24.txt:00:54:22: <lament> i thought we went through all this in detail when we were discussing Banana Scheem.
|
|
|
149 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.)
|
|
|
150 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.
|
|
|
151 2006-08-29.txt:01:22:14: <Razor-X> Instead of binding head and tail via let, pattern matching is actually pretty nifty.
|
|
|
152 2006-08-29.txt:01:23:22: <GreyKnight> Razor-X: what's this pattern-matching head/tail of which you speak?
|
|
|
153 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.
|
|
|
154 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))
|
|
|
155 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
|
|
|
156 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'
|
|
|
157 2006-09-02.txt:03:23:24: <GreyPaladin> I find if you give the eta a slightly hooked tail, it helps
|
|
|
158 2006-09-02.txt:03:23:48: <Razor-X> I make the curve start very high and make the right tail extend lower.
|
|
|
159 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
|
|
|
160 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. . . ;)
|
|
|
161 2006-09-04.txt:03:22:44: <GreyKnight> the top hook and the tail should be pretty prominent
|
|
|
162 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.
|
|
|
163 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).
|
|
|
164 2006-09-11.txt:03:17:18: <sparr_> i have been using applicators directly, but the level of control and detail is quite lacking
|
|
|
165 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
|
|
|
166 2006-09-24.txt:19:16:46: <SimonRC> give details
|
|
|
167 2006-10-06.txt:00:27:40: <pikhq> Allow me to specify in more detail. . .
|
|
|
168 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...
|
|
|
169 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.
|
|
|
170 2006-10-18.txt:02:52:27: <Sgeo> I need more details though
|
|
|
171 2006-10-21.txt:21:05:44: <Razor-X> But it uses recursion, and I'm not using tail recursion here.
|
|
|
172 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.
|
|
|
173 2006-10-23.txt:22:05:03: <Asztal> Do people just submit statements, not knowing any details of the rest of the language?
|
|
|
174 2006-10-29.txt:08:49:53: <thematrixeatsyou> . = wire, + = tail, * = electron
|
|
|
175 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
|
|
|
176 2006-11-03.txt:19:22:59: <SimonRC> detail (v.)
|
|
|
177 2006-11-17.txt:00:54:15: <xor_> But tail recursion a la scheme is ugly too
|
|
|
178 2006-11-17.txt:00:56:01: <Razor-X> Tail recursion is made effecient.
|
|
|
179 2006-11-17.txt:00:56:19: <Razor-X> Almost all of Lisp's idioms encourage the use of tail recursion. Haskell does too.
|
|
|
180 2006-11-17.txt:02:55:53: <xor_> Please support your awnser with a detailed explaination
|
|
|
181 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.
|
|
|
182 2006-11-26.txt:04:17:27: <GreaseMonkey> 1 = electron -> tail (2)
|
|
|
183 2006-11-26.txt:04:17:34: <GreaseMonkey> 2 = tail -> wire (3)
|
|
|
184 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
|
|
|
185 2006-11-27.txt:06:33:57: <Razor-X> Mmmf. GreaseMonkey: Explain your architecture in a bit of detail.
|
|
|
186 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.
|
|
|
187 2006-12-02.txt:06:00:55: <Razor-X> Tail recursion, rather.
|
|
|
188 2006-12-02.txt:06:01:17: <twobitsprite> factor has full tail-call optimization
|
|
|
189 2006-12-02.txt:06:01:17: <Razor-X> It has tail recursion (by way of RECURSE), but it's not used very often.
|
|
|
190 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
|
|
|
191 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.
|
|
|
192 2006-12-02.txt:22:41:48: <Razor-X> There's your effecient tail recursion.
|
|
|
193 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
|
|
|
194 2006-12-15.txt:22:00:00: <SimonRC> :-S http://www.propeller-island.de/rooms_neu/room_detail/23/index.php
|
|
|
195 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
|
|
|
196 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
|
|
|
197 2006-12-28.txt:18:25:24: <pikhq> (look in macro.tcl, proc string, for the gory details)
|
|
|
198 2006-12-30.txt:20:19:54: <RodgerTheGreat_> advanced looping constructs aren't that vital if we allow normal- and tail-recursion
|
|
|
199 2006-12-30.txt:20:33:17: <CakeProphet> we can work out syntatical details later.
|
|
|
200 2006-12-30.txt:21:44:32: <CakeProphet> *shrugs* nothing detailed... just "sbustition".
|
|
|
201 2006-12-31.txt:05:12:36: <CakeProphet> yeah... there's a lot of details you can specify in a kernel.
|
|
|
202 2007-01-02.txt:04:10:47: <oerjan> you might want to adjust run to do proper tail call optimization.
|
|
|
203 2007-01-02.txt:04:23:35: <CakeProphet> hmmm... to make it do optimization for tail recursion you simply return the call right?
|
|
|
204 2007-01-07.txt:18:13:01: <SimonRC> see The Repositor Of All Huma Knowlage for more details
|
|
|
205 2007-01-12.txt:03:54:10: <bsmntbombdood> oerjan: partitition(sep) => (head, sep, tail)
|
|
|
206 2007-01-14.txt:01:59:20: <oerjan> Note that if it is tail recursive the recursion may be optimized away.
|
|
|
207 2007-01-14.txt:01:59:57: <bsmntbombdood> tail recursion modulo cons?
|
|
|
208 2007-01-19.txt:23:40:02: <oklopol> since there would be an infinite series of numbers as the decimal tail
|
|
|
209 2007-01-21.txt:15:51:42: <oklopol> you can read the server rfc if you care about details :)
|
|
|
210 2007-02-01.txt:01:31:39: <SimonRC> bsmntbombdood: you mean: "fibbs = 0:1:zipWith (+) fibbs (tail fibbs)"
|
|
|
211 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.
|
|
|
212 2007-02-18.txt:23:55:30: <oerjan> Make that fibseq = '0' : tail (concatMap s fibseq) where s '0' = "01"; s '1' = "0"
|
|
|
213 2007-02-22.txt:17:06:03: <ais523> because I haven't figured out the details
|
|
|
214 2007-02-22.txt:18:46:52: <ais523> http://alexa.com/data/details/traffic_details?url=esolangs.org
|
|
|
215 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.
|
|
|
216 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.
|
|
|
217 2007-03-05.txt:03:32:57: <bsmntbombdood> too bad it doesn't optimize tail recursion
|
|
|
218 2007-03-05.txt:03:35:11: <bsmntbombdood> looks like it optimizes tail recursion!
|
|
|
219 2007-03-05.txt:03:36:50: <bsmntbombdood> up to a million tail calls...
|
|
|
220 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.)
|
|
|
221 2007-03-09.txt:16:06:37: <oerjan> which is a tailor series.
|
|
|
222 2007-03-16.txt:00:26:31: <oerjan> it's even tail recursive
|
|
|
223 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
|
|
|
224 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.
|
|
|
225 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
|
|
|
226 2007-03-21.txt:23:27:21: <lament> that's basically it, the devil's in the details...
|
|
|
227 2007-03-22.txt:19:10:55: * SevenInchBread is beginning to become weary of all the strictness entailed in computing...
|
|
|
228 2007-03-25.txt:00:59:26: <SevenInchBread> neat, detail-oriented, good concentration, organized. ....I'm the polar opposite of that.
|
|
|
229 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
|
|
|
230 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
|
|
|
231 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.
|
|
|
232 2007-03-27.txt:02:22:17: <oerjan> and thereby ruined tail call optimisation
|
|
|
233 2007-03-28.txt:01:57:02: <Figs> http://www.netscrap.com/netscrap_detail.cfm?scrap_id=85
|
|
|
234 2007-03-29.txt:18:46:17: <oerjan> let f l = 1 : zipWith (+) l (tail l) in fix f
|
|
|
235 2007-03-29.txt:18:51:43: <oerjan> let fib = 1 : 1 : zipWith (+) fib (tail fib)
|
|
|
236 2007-04-02.txt:22:40:18: <CakeProphet_> ...just... a part... with all the vagueness entailed.
|
|
|
237 2007-04-02.txt:22:52:33: <lament> we can still "explain" them by detailing their behavior
|
|
|
238 2007-04-08.txt:01:16:49: <Pikhq> GregorR: Describe it; the page doesn't detail much.
|
|
|
239 2007-04-08.txt:23:50:12: * oerjan is not versed in the details of this.
|
|
|
240 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.."
|
|
|
241 2007-04-11.txt:02:11:30: <Pikhq> GregorR: Hmm. I need to see some details on the SPS internals. . .
|
|
|
242 2007-04-11.txt:03:48:49: <Pikhq> See the GCC documentation (under Gcov) for details on how to use it. . .
|
|
|
243 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.
|
|
|
244 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.
|
|
|
245 2007-04-27.txt:19:35:21: <lament> 39, hasekll: let f=0:1:zipWith(+)f(tail f)in f!!435
|
|
|
246 2007-04-28.txt:04:31:26: <oerjan> ok unoptimized tail recursion
|
|
|
247 2007-04-28.txt:05:39:06: <oerjan> if you do something like (cons a (tail b))
|
|
|
248 2007-04-28.txt:06:10:58: <bsmntbombdood> a pair (pointer to head, pointer to tail)
|
|
|
249 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
|
|
|
250 2007-05-25.txt:04:02:03: <ihope> Oh, that page details it.
|
|
|
251 2007-05-27.txt:23:45:44: <SimonRC> bsmntbombdood: give details
|
|
|
252 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.
|
|
|
253 2007-06-01.txt:02:51:58: <bsmntbombdood> there's a good talk somewhere that he explains it in detail
|
|
|
254 2007-06-07.txt:19:34:35: <SimonRC> let { foo = "0" ++ (tail $ concat [if c == '0' then "01" else "10" | c <- foo]) } in foo
|
|
|
255 2007-06-14.txt:19:37:56: <pikhq> The tape is merely finite, but that's an implementation detail.
|
|
|
256 2007-06-16.txt:00:50:36: <bsmntbombdood> CPS makes call/cc and tail call optimization very easy
|
|
|
257 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.
|
|
|
258 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
|
|
|
259 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.
|
|
|
260 2007-06-23.txt:21:20:48: <Sukoshi> Square tiles. GBA detail.
|
|
|
261 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
|
|
|
262 2007-06-29.txt:03:42:22: <ihope> Does it have details on why it failed?
|
|
|
263 2007-06-30.txt:19:00:35: <Tritonio> I don't understand a detail.
|
|
|
264 2007-07-02.txt:09:08:46: <immibis> !factoid alzcwat is you do to a lion zebra crossover with a tail
|
|
|
265 2007-07-02.txt:09:08:55: <immibis> !factoid alzcwat is a lion/zebra crossover with a tail
|
|
|
266 2007-07-02.txt:09:09:01: <toBogE> alzcwat is a lion/zebra crossover with a tail
|
|
|
267 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
|
|
|
268 2007-07-04.txt:04:13:38: <lament> like i said, look at forth in more detail
|
|
|
269 2007-07-04.txt:16:54:53: <oklopol> most people like to think most details in organisms are there because they're optimal
|
|
|
270 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
|
|
|
271 2007-07-05.txt:23:00:03: <RodgerTheGreat> yes. In great detail
|
|
|
272 2007-07-09.txt:05:24:27: <Sukoshi> I'm glad you're not adding graphic detail to that :P
|
|
|
273 2007-07-09.txt:06:16:22: <fax> you cant store the head, you need to head and head of tail
|
|
|
274 2007-07-09.txt:06:17:04: <bsmntbombdood> head and tail are stored normally
|
|
|
275 2007-07-09.txt:06:19:11: <bsmntbombdood> fax: no point in a doubly linked list without storing the tail
|
|
|
276 2007-07-09.txt:21:42:48: <edwardk> it has tail call optimization
|
|
|
277 2007-07-11.txt:00:33:11: <bsmntbombdood> Sukoshi: iteration is only tail recursion
|
|
|
278 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
|
|
|
279 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
|
|
|
280 2007-07-14.txt:00:41:36: <lament> books by serious writers often have detailed commentaries that list and explain all the references
|
|
|
281 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
|
|
|
282 2007-07-14.txt:06:47:33: <pikhq> Using it as a title usually entails the artistry of your work.
|
|
|
283 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
|
|
|
284 2007-07-14.txt:21:22:03: <GregorR-L> Red-tail boa constrictors.
|
|
|
285 2007-07-14.txt:22:07:43: <RodgerTheGreat> ^ that is a much more detailed description
|
|
|
286 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 :=)
|
|
|
287 2007-07-19.txt:16:28:09: <oklokok> stop complaining about details, choosing a representation isn't programming :)
|
|
|
288 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.
|
|
|
289 2007-07-22.txt:22:50:06: <ehird`> tail-recursion optimization? absolutely free!
|
|
|
290 2007-07-23.txt:19:09:01: <lament> tail-recursively!
|
|
|
291 2007-07-23.txt:20:59:09: <oklofok> well anyway, it's a few details over that
|
|
|
292 2007-07-23.txt:22:29:02: <bsmntbombdood> oklofok: that can be made tail recursive easily, i just didn't bother
|
|
|
293 2007-07-26.txt:23:57:50: <SimonRC> CPS requires that all the continuation calls be tail-calls
|
|
|
294 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
|
|
|
295 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
|
|
|
296 2007-08-02.txt:21:07:28: <ehird`> i think being more detailed would be much complexity for something that isn't needed
|
|
|
297 2007-08-10.txt:01:15:52: <ihope> I don't remember the details.
|
|
|
298 2007-08-12.txt:20:20:48: <ehird`> very detailed colours
|
|
|
299 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
|
|
|
300 2007-08-14.txt:22:54:54: <ehird`> or have a weird tail-call optimization-implementing interp
|
|
|
301 [too many lines; stopping]
|
