15:15 <mellum> I want to have a data structure that I will only access with C functions. It should have 260 bits. WHat Ocaml type should I choose?

15:22 <Smerdyakov> Why not create it in C? =)

15:23 <mellum> Smerdyakov: because C memory management sucks.

15:24 <cm> umm

15:26 <Smerdyakov> I don't know much about OCaml FFI.

15:26 <Smerdyakov> In SML/NJ, you can declare C arrays of fixed sizes.

15:28 <mellum> Ah, I think I found something in the manual

18:36 <phubuh> hello

22:22 <pattern> i've just started teaching myself o'caml from the "introduction to the objective caml programming language" tutorial by jason hickey

22:23 <pattern> in chapter 3, in the "Higher order functions" section i come across this example for a derivative:

22:29 <pattern> http://pastecode.net/index.php?tag=171

22:32 <steele_> any question about that code?

22:32 <pattern> yeah... is it deliberately obscure?

22:33 <pattern> or is this just a bad tutorial?

22:34 <pattern> is there a clearer way to write that in ocaml?

22:34 <pattern> or is that as clear as it gets?

22:34 <pattern> because it's not clear... and there are no comments

22:34 <steele> =) IMHO the only important thing is the deriv function and that is pretty clear to me

22:34 <pattern> and the 'f' and 'x' variables don't seem to have been chosen for clarity

22:35 <pattern> variable names, i mean

22:35 <pattern> i guess it's just me, then

22:36 <steele> you get used to it

22:36 <pattern> i have another question, then

22:37 <pattern> he follows this example up with the note: "Remember, the arrow associates to the right, so another way to write the type is (float -> float) -> (float -> float). That is, the derivative is a function that takes a function as an argument, and returns a function.

22:37 <pattern> he's referring to this line: val deriv : (float -> float) -> float -> float = <fun>

22:38 <pattern> now, what in that says that it's a function?

22:38 <pattern> is it the parenthesis?

22:38 <pattern> i mean, what it's a function that takes a function as an argument and returns a function

22:38 <steele> the first parenthesis is needed

22:38 <phubuh> the arrow operator makes it a function definition

22:38 <steele> eg it takes a function

22:39 <pattern> i see

22:39 <steele> the second is implicit because of right associativity

22:39 <pattern> it's the arrow operator that says it's a function... and the fact that it takes a function as an argument is inferred from what?

22:40 <phubuh> (t1 -> t2) is a function

22:40 <phubuh> or rather, is the type of a function

22:40 <pattern> yes, i see that the right associativity makes you put parenthesis around the float -> float

22:41 <pattern> oh, ok

22:41 <pattern> i was somehow missing the -> inside the parenthsis :)

22:41 <pattern> selective blindness :)

22:42 <pattern> now it makes utterly clear sense

22:42 <pattern> clearer than clear... thank you!

22:45 <pattern> i guess those are the kinds of things that need to be spelled out and repeated for an utter novice: "remember the arrows mean 'function'... see, there are three of them? the first means the argument is a function, and the second means the whole statement is a function, and the third means the result is a function"

22:45 <pattern> :)

22:46 <pattern> i'm still havning a problem wrapping my mind around the deep recursion, though

22:47 <pattern> i'm too used to plain iteration

22:48 <pattern> i can understand how recursion works if i sit down and work out what happens in the function, step by step, for certain given values... but how i would ever think of writing such a function is beyond me, at this point

22:50 <pattern> do any of you know of a text that explores the why's and wherefores of recursion in a clear manner?

22:56 <mellum> "Structure and Interpretation of Computer Programs" by Abelson, Sussman and Sussman

22:56 <pattern> cool, thank you, mellum

22:57 <phubuh> it's available for free, search for sicp on google

22:57 <Zadeh> There's a free online version if you don't mind reading on the computer

22:57 <steele> there is something about recursive vs iterative in the ocaml book:

22:57 <steele> http://caml.inria.fr/oreilly-book/html/book-ora037.html#toc47

22:58 <pattern> free is good... :) on amazon they sell if for $70 !!

22:58 <lament> http://mitpress.mit.edu/sicp/

22:59 <lament> note that when reading SICP you will also learn Scheme as a side-effect

23:00 <pattern> i've heard good things about scheme

23:01 <lament> For a reason.

23:01 <lament> SICP is not a scheme book, but it uses scheme for the examples

23:01 <cm> SICP gonna ship tomorrow :)

23:01 <cm> i read parts of the online version, but i prefer the book version for reading

23:02 <lament> heh

23:02 <cm> plus it looks cool in the shelf :P

23:02 <pattern> me too.. but i can't splurge $70 on yet another computer book

23:02 <lament> SICP is one of the few books i'd like to have in dead-tree

23:02 <pattern> maybe i can get it used, though... i'll put it on my half.com wish list for $10 :)

23:04 <pattern> hey, a 1985 edition is available on half.com for $8.95

23:04 <pattern> great :)

23:05 <cm> :)

23:05 <pattern> is there a big difference between the '85 and '96 editions?

23:08 <pattern> heh... i just found the "Skeptical Software Engineering Bibliography"

23:09 <pattern> "Software engineering (SE) has probably largest concentration of snake oil salesmen. Even object-oriented design cannot compete with SE ;-). Such "dynamic" figures as Yourdon, Ben Shneiderman and partially Gerard Weinberg (at least the latter authored one interesting book and a couple of decent tutorials on PL/1), could probably compete with any woman fashion designer :-). These guys are really can change their own position twice a week, as t

23:09 <pattern> sense that something new becomes fashionable."

23:09 <pattern> http://www.softpanorama.org/Bookshelf/se.shtml