<Drup>
rgrinberg: the module alias stuff in 4.02 solve the whole pack situation better, I presume
<Drup>
I don't feel like adding more pack stuff is a good solution, at least.
<rgrinberg>
how so? i thought the module alias is just a performance tweak
<Drup>
not exactly, it will also avoid recoyping type interface with "module type of BLA"
<Drup>
various subtle type checking behavior at the type equality level, too
<Drup>
module equality*
<rgrinberg>
hmm.. when I look at packed functors I see them as a more convenient mechanism for parameterizing a whole library. Not sure how module alias could help out with that.
<rgrinberg>
but this is the first time I've seen this proposal
<Drup>
right
<Drup>
I don't know the official opinion on the questoin
fraggle_laptop has quit [Ping timeout: 255 seconds]
<Drup>
question*
shinnya has quit [Ping timeout: 250 seconds]
<Drup>
but I don't like the idea of external flags that change the signature of a library and that you can't see in .mli :/
fraggle_laptop has joined #ocaml
<rgrinberg>
haven't thought of that
<rgrinberg>
it certainly doesn't seem elegant
q66 has quit [Quit: Leaving]
jprakash has quit [Quit: leaving]
araujo has quit [Read error: Connection reset by peer]
<Drup>
whitequark: ok, back and ready, let's try to fiddle with these env variables
rgrinberg has quit [Quit: Leaving.]
araujo has joined #ocaml
<whitequark>
Drup: do you ever, you know
<whitequark>
sleep
<Drup>
of course
<Drup>
during the first half of the day
<Drup>
while everyone is getting up, I go to bed
<Drup>
:D
<whitequark>
how is that compatible with being an employee / student ?
<Drup>
:research:
<whitequark>
uh, yeah, and?
<whitequark>
you don't have to show up?
<Drup>
occasionally ?
<whitequark>
oh, cool
<whitequark>
so it's basically remote work, but in academia
<Drup>
it depends of your statue I guess, and the way you are working
<whitequark>
... statue?
<Drup>
huu, wrong word.
<Drup>
status* :D
<Drup>
(it's not even the right one in french, I have no excuses)
<whitequark>
it is known: Drup has a statue
<Drup>
but at least, as an intern, my advisors were all ok with me having weird hours and showing up only for meetings.
<Drup>
whitequark: I don't find documentation on this env variable, how do I set them ?
<Zemeio>
Guys, can anyone help me? I am trying to build my project (frenetic project) and i keep geting an error saying that it does not find "async_netkat". I know where the .cmx is, but it is not linking properly. I am still new at the language.
jao has quit [Ping timeout: 245 seconds]
<whitequark>
Zemeio: try adding -package netkat to your "ocamlfind ocamlc" invocation
<whitequark>
or at least say what build system are you using
<Zemeio>
sorry, i am using corebuild with -pkg netkat,async,openflow
<Zemeio>
the OS is ubuntu 14.04 (in case it is relevant)
<Drup>
ahah, I'm an idiot
<Drup>
10 minutes of walking around oasis configure
<Drup>
I forgot to put my new function in the .mli
<whitequark>
I concur
ygrek has quit [Ping timeout: 240 seconds]
<Drup>
ok, an llvm assert :(
<whitequark>
to the gdb
<Drup>
no need
<Drup>
whitequark: off by one error in the ocaml code which was not triggered by Llvm.operand by is by operand_use, for whatever reason
<Superpelican_>
Drup: Ok, so I’ve found out that Tsdl doesn’t release SDL resources automatically, so I’m leaking memory, but what if creating something fails? Then I need to release the resources too
<Drup>
Hum, I don't know Tsdl :D
<Drup>
never used, never even looked at the API
<Drup>
so, hum, look for a function to release ressources, I guess ?
<mrvn>
Superpelican_: set up a Gc.finalize to free them
<Superpelican_>
Drup: Do I have to pass all those resources including the renderer and window?
<Superpelican_>
for example I have a function that loads a bitmap into memory
<Drup>
what mrvn said is probably a good solution
<Superpelican_>
yes, but does the OCaml GC even have control over SDL/C resources?
<Drup>
no it does not
<Drup>
but that doesn't matter
avsm has quit [Quit: Leaving.]
<Superpelican_>
please explain :)
<mrvn>
For ZeroMQ what I did was write thin bindings with ctypes that would leak and then use that in a module that implement more sane bindings and handles freeing resources and creating exceptions on error and so on.
<Superpelican_>
yes
<Superpelican_>
I guess that is pretty similiar to my situation with tsdl
<Superpelican_>
which is also a thin binding
<Drup>
Superpelican_: you will make a small function "create_ressource"
<Superpelican_>
almost all the functions map directly to C functions
<Superpelican_>
but beware it’s “under construction”
<Superpelican_>
so the code doesn’t completely make sense ;)
<mrvn>
Superpelican_: after line 16 you would call Gc.finalize shutdown win
<Superpelican_>
for example I should change the update_window_surface to render_present etc.
<mrvn>
Superpelican_: in line 19 you do the same for renderer
<Superpelican_>
yes, but how does the OCaml GC know about what Sdl.destroy_* does?
<mrvn>
Superpelican_: it doesn't care
<mrvn>
Superpelican_: it just calls shutdown when win becomes unreachable
<ggole>
At some point after it becomes unreachable, really
samrat has joined #ocaml
<mrvn>
Superpelican_: or whatever function you attach
<Superpelican_>
well I try to explain what my code does
<Superpelican_>
I -> I'll
<mrvn>
Superpelican_: no need
<Superpelican_>
mrvn: hmm, but win never becomes unreachable
<Superpelican_>
Or does it?
<mrvn>
Superpelican_: change line 40 to "let main () = ..." and add "let () = main (); Gc.full_major (); Gc.full_major ()
<Superpelican_>
mrvn: The problem is, if for example loading the bitmap fails, I’ll need to release/free the window (win) and the renderer (renderer)
<Superpelican_>
normally I wouldn’t need to pass win and renderer to my loadTex(ture) function
<mrvn>
or better "let () = let res = try main (); None with _ as exn -> Some exn in Gc.full_major (); Gc.full_major; match res with None -> () | Some exn -> raise exn
<Superpelican_>
But I can’t free them if loading the bitmap fails if I don’t pass them to loadTex
<Superpelican_>
But I don’t want to clutter up all my functions with those arguments
<mrvn>
Superpelican_: the Gc will free them
<Superpelican_>
mrvn: But how does the GC know when to free them?
<Superpelican_>
Because win won’t become unreachable
<Superpelican_>
because it’s never freed
<mrvn>
because they become unreachable
samrat has quit [Ping timeout: 250 seconds]
<Superpelican_>
mrvn: You mean after exit?
<mrvn>
Superpelican_: no. unfortunetly not. That's why you need the bit of code from above
<Superpelican_>
Yes, but won’t win only become unreachable *after* exit?
<mrvn>
The Gc runs every now and then in a longer running program but at exit you have to trigger it manually to get it to run one final time before exiting.
claudiuc_ has quit [Remote host closed the connection]
<Superpelican_>
mrvn: I understand
<mrvn>
Superpelican_: win becomes unreachable when line 40 returns
<mrvn>
which means you need to remove line 46 by the way.
<Superpelican_>
mrvn: So you mean let () will return when loadTex returns when an error occurs while trying to load the bitmap?
<ggole>
What's wrong with good old try let res = create_thing () in foo (); dispose res with exn -> dispose res; raise exn?
<Superpelican_>
mrvn: BTW why change let () to let () = main () and let main () = ?
thomasga has quit [Quit: Leaving.]
<ggole>
It should work if the lifetime of the thing is clear
<mrvn>
Superpelican_: so main gets called and after that you invoke the Gc
<Superpelican_>
mrvn: So: “let () = main (); invokeGC ()”?
<mrvn>
ggole: that would be the "with_foo ..." style of handling this
ygrek has joined #ocaml
<mrvn>
Superpelican_: yes. Adding a try ... with around it to handle exceptions if you use those
<Superpelican_>
mrvn: Well Tsdl doesn’t seem to use exceptions, but just polymorphic variants to return either `Error or `Ok, so l’m forced to use match bodies
<mrvn>
ggole: problem with that approach is that you can't garantee that the resource does not escape the scope
<mrvn>
Superpelican_: nothing stops you from matching those and then raising exceptions
<ggole>
Then stick on finalize as well (preferably with a bit of code that shouts that you are doing it wrong)
<Superpelican_>
mrvn: And exceptions don’t have scope?
<mrvn>
Superpelican_: or any other thing can raise exceptions, like List.find
<Superpelican_>
If exceptions are global, that maybe the key to the solution
<Superpelican_>
Because then I could handle the exceptions in let ()
<Superpelican_>
hmm
<mrvn>
Superpelican_: exceptions have a namespace. Not sure what you mean by scope
racycle has joined #ocaml
<Superpelican_>
mrvn: I mean if loadTex raises an exception upon matching `Error that exception could then be handled in let ()
<Superpelican_>
And win and renderer are in the scope of let ()
<mrvn>
exception Error of string let create_texture_from_surface imgSurface = match match Sdl.create_texture_from_surface imgSurface with | `Error err -> raise (Error err) | `Ok imgTexture -> imgTexture
samrat has joined #ocaml
avsm has joined #ocaml
<mrvn>
you can raise and catch exceptions anywhere you like
<Superpelican_>
ok, so they are “global"
<mrvn>
no
<Superpelican_>
but then we still have the problem that try is of course imperative
<Superpelican_>
and not event driven
<Superpelican_>
So loadTex would still need to notify let () that something went wrong while trying to load the bitmap
<mrvn>
Superpelican_: you should read up and play with exceptions. You seem to never have used them
<Superpelican_>
mrvn: I did use them in Python briefly, but you’re right that I haven’t used them yet in OCaml
eikke__ has quit [Ping timeout: 240 seconds]
<Superpelican_>
mrvn: I’ll read up on exceptions in OCaml first and then come back :)
<Superpelican_>
maybe it will provide a whole new perspective on how to solve the releasing of the SDL resources
<Superpelican_>
(for me ;) )
<ggole>
I have to admit that I don't see the difficulty
WraithM has quit [Remote host closed the connection]
<mrvn>
exceptions won't release resources. they just manage the control flow
<mrvn>
ggole: me neither. This is so fundamental that I can't even explain it
<Superpelican_>
mrvn: Are you fond of Real World OCaml, or do you recommend something else (especially when considering RWO’s chapter “Error Handling” which I guess covers exceptions)?
<mrvn>
never read Real World OCaml. Didn't exist when I started
<Superpelican_>
;)
pyon has quit [Quit: Fiat justitia ruat caelum.]
samrat_ has joined #ocaml
samrat has quit [Ping timeout: 272 seconds]
samrat_ is now known as samrat
studybot_ has quit [Ping timeout: 264 seconds]
<Superpelican_>
mrvn: I know exceptions don’t release resources
<Superpelican_>
mrvn: But you can use them to do that, right?
<ggole>
Not really
<mrvn>
you can use them to set off a nuclear explosion if you got the bomb
<ggole>
You use ordinary code to release resources
<ggole>
The trick is that exceptions can bypass that code, which is why you need to fiddle about with try
<Superpelican_>
Drup: LOL “raise”
<mrvn>
try ... with Release foo -> foo ()
thomasga has joined #ocaml
<Superpelican_>
ok I really think I indeed should read up about exceptions in OCaml
<Superpelican_>
because they seem to be different than those in Python
<mrvn>
not really, or at all
<mrvn>
exceptions are pretty much the same everywhere
samrat has quit [Ping timeout: 255 seconds]
<Superpelican_>
LOL :OCaml doesn't have quite such a rich set of debugging commands - better than Java, about the same as C, not nearly as good as Perl.” - OCalm documentation
<Superpelican_>
Are they reallly claiming that C has a richer set of debugging commands than Java?
<Superpelican_>
Or is this just a mistake?
<mrvn>
Superpelican_: ever used gdb?
<Superpelican_>
well I did use it a few times
<Superpelican_>
but that was pretty basic
<Superpelican_>
I never used it’s advanced features
<Superpelican_>
only print the value of the variable and execute until line X etc. ;)
<Superpelican_>
Although it did help me catch some bugs
WraithM has joined #ocaml
<Superpelican_>
mrvn: But gdb isn’t really a language feature
<Superpelican_>
so I wouldn’t call it a “debugging command"
<whitequark>
def`: a very british-imperialistic point of view
<Drup>
except when you do math, in this case, it can be actually useful
<whitequark>
"everyone must learn english or die"
<def`>
whitequark: what are you going to do about that? change keywords?
<whitequark>
def`: for instance
* adrien
grabs Drup, kicks him on the head, ties him, cuts his tongue, put him in a box and ships it to antarctica
<def`>
keywords are already in "english" (wow, actually that's ocaml, not english)
<Drup>
adrien : you would like my current code
<whitequark>
def`: still, you are basically discounting every culture outside english-speaking world
<Drup>
It's almost literate linear algebra programming
<whitequark>
the latter is, in fact, a minority.
<def`>
whitequark: if the whole language is designed to allow non ascii names, then why not. but in the current situation, it would introduce a lot of confusion
<adrien>
as long as you don't publish it :P
<Drup>
with lot's of utf8 symbols in the comments, to explain what the fuck it is doing
<dmbaturin>
Non-english keywords? Tell the difference between "let" and "lеt".
<dmbaturin>
(Spoiler: the latter has cyrillic 'е' instead of lating 'e' in it)
<whitequark>
def`: huh? you would need to allow utf-8 longidents and add collation support for the module capitalization trick
<dmbaturin>
* latin
<def`>
dmbaturin: that's precisely what I am worried about
<Drup>
you can catch that by normalization, though
<whitequark>
def`: Java and JavaScript do this for ages. it is not exactly complex.
<whitequark>
Drup: not really
<whitequark>
there's no normalization mode that converts е to e
<Drup>
really ?
<whitequark>
as far as I'm aware
<Drup>
weird
<whitequark>
that's because they are completely different characters that happen to share a grapheme
<dmbaturin>
Actually, there were several cyrillic-based languages in the USSR, including Ada with translated keywords. The Ada standard required that compliers treat identical looking cyrillic and latin characters as equal.
<whitequark>
dmbaturin: neat
<whitequark>
and horrible
<Drup>
x)
<whitequark>
anyway, you could trivially add an editor extension that would highlight mixed-language identifiers
<dmbaturin>
I think compiler authors had to invent new swear words to describe that idea. :)
<Drup>
whitequark: there is an issue with allowing utf8 arbitrarily, which I personally call "Haskell operator madness"
<whitequark>
Drup: wait, they ALSO use UTF-8?
<whitequark>
that upgrades it from "insane" to "completely deranged"
<Drup>
of course they do
<whitequark>
Drup: in my view, if you have more than ten operators apart from the arithmetic stuff everyone knows, you're doing it wrong and please stahp
<mrvn>
4 for ints, 4 for floats, 4 for 2D vectors, 4 for 3D vectors, 6 for matrixes
<Drup>
ahah
<whitequark>
mrvn: ffuuu
<whitequark>
also there is `mod`
<whitequark>
so five
troutwine is now known as troutwine_away
<def`>
whitequark: did you suffer having to learn the 26 characters of ascii alphabet? :|
<mrvn>
6 for bit operations
<Drup>
whitequark: if your language is function, you will want |>, @@ and .
<mrvn>
2 for function combination
<Drup>
functional*
<whitequark>
def`: imagine reading a codebase where every single identifier is translitedated in slightly different ways by a dozen of programmers
<Drup>
no, 3 for function combination
<whitequark>
none of whom knows english
<whitequark>
fuck that
<Drup>
we lack one in ocaml
<whitequark>
Drup: |> @@ @ ^ and >>=
<whitequark>
and be done with it
<Drup>
@ ?
<whitequark>
List.concat
<mrvn>
Drup: ok. Ocaml already has 16 operators defined that I've used
<Drup>
whitequark: no, that's +
<def`>
whitequark: use conceal to turn _hexencoding to a proper character :P
<Drup>
don't need it.
<mrvn>
Drup: @ ist a constructor
<whitequark>
Drup: no, that's not +
<whitequark>
at least if your + is the part of a Num typeclass
<whitequark>
how would you define - or * for lists?
<Drup>
right, depends on how you do it, ok
<whitequark>
def`: what's your opinion here, btw?
<mrvn>
whitequark: removal of elements and pairwise tuples
<whitequark>
mrvn: but - has the signature 'a -> 'a -> 'a
<def`>
whitequark: on operators?
<whitequark>
for the whole Num typeclass
<whitequark>
def`: yes
<dmbaturin>
"-" could find if the lists have common beginning and return the difference.
<mrvn>
[1; 2] - [2; 3] = [1]
<Drup>
mrvn: please die
<Drup>
=')
<def`>
:D
<whitequark>
dmbaturin: mrvn: but that wouldn't follow the usual arithmetic rules for + and +
<whitequark>
er, + and -
<mrvn>
whitequark: true.
<whitequark>
x - y + y ≠ x
<dmbaturin>
whitequark: Of course it wouldn't, I never said otherwise.
<mrvn>
it is a bad idea
<whitequark>
then it should die in a fire
<whitequark>
def`: I think there should be a distinct "Concat" typeclass
<whitequark>
for strings, ropes, arrays, byte arrays, lists, ...
<jpdeplaix>
whitequark: llvm.moe <3
<whitequark>
you could have @ as its sole member
<whitequark>
jpdeplaix: ;D
<def`>
whitequark: I thought of "monoid"
<whitequark>
def`: "monoid"?
<mrvn>
whitequark: so no more ^?
<whitequark>
mrvn: yes
<Drup>
whitequark: @
<Drup>
it's call monoid
<def`>
whitequark: "a category with only one object"
<whitequark>
def`: can you please explain in English
<Drup>
no, don't say it like that T_T
<Drup>
whitequark: a set with a zero and an addition
<Drup>
so, Z, lists, trees
<whitequark>
Drup: okay
<whitequark>
please don't call it "monoid"
<Drup>
It's the right term
<whitequark>
I know
<Drup>
and it's not even category theory
<def`>
whenever you can concat, with concatenating a zero being a no-op, you have a monoid
<Drup>
it's just group theory, which is slightly less insane
<whitequark>
I just don't want #ocaml to turn into #haskell
<def`>
the name Monoid comes with a set of laws
<whitequark>
because every time you say anything vaguely related to category theory, even if correct, any rational thought stops and shit starts being dispersed by fans
<def`>
without having to lookup the documentation
<whitequark>
def`: I know
<dmbaturin>
whitequark: Let's turn #haskell into #ocaml instead.
<Drup>
whitequark: I told you, it's not category theory T__T
<whitequark>
personally, I have no objections to monads or monoids or whatever
<def`>
whitequark: you're right
<whitequark>
Drup: "vaguely related"
<Drup>
well
<Drup>
some math thingy is vaguely related to some other math thingy
<Drup>
yeah, sure.
<whitequark>
Drup: that is exactly how the holy war would go
<whitequark>
so I intentionally said it like that.
<def`>
whitequark: the problem with software engineer is that all concepts have a vague definition, if any
<def`>
engineering*
<whitequark>
def`: to be honest I see no big problem with typeclass "Concat" defined as "you can concat, with concatenating a zero being a no-op"
<ggole>
Software is vague and precise at the same time, it's the nature of the beast.
<def`>
whitequark: and concatenation is associative :P
<whitequark>
it is a precise definition and it is understandable by literally anyone who has touched any language at all
<whitequark>
yeah, associative
<Drup>
whitequark: well, concat is still weird, semantically
<whitequark>
Drup: why?
<Drup>
because Z is a monoid
<Drup>
do you say you concatenate integers ?
<def`>
ggole: you can trust the implementation but not the implementor… that's not really helpful :P
<Drup>
do you concatenate trees ?
<whitequark>
I don't think we need Concat implementation for integers ;P
<whitequark>
+ is enough
<def`>
Drup: as in type nat = unit list :D ?
<Drup>
def`: psss, don't say anything !
<whitequark>
Drup: hm, and how would you define Monoid for trees?
<dmbaturin>
10 `concat` 4 = 104 ;)
<Drup>
whitequark: binary trees, you "concat" by creating a node with two subtrees
<whitequark>
ok
<whitequark>
then I definitely say it is just concatenation
<def`>
dmbaturin: wrong channel :)
<def`>
Drup: your definition of trees concatenantion doesn't look associative !
<Drup>
hum, that's right
<def`>
/kickbankick
<Drup>
(there is even en haskell blog post about that)
<dmbaturin>
There's a special name for non-associative algebraic structure. Magma or something.
<Drup>
(which was actually interesting)
<Drup>
yes, magma
<whitequark>
"magma" ?
<Drup>
whitequark: the same as monoid, but you don't require associativity
<dmbaturin>
Disclaimer: I'm exactly an abstract algebra fan, not category theory fan. :)
<def`>
and no unit
<Drup>
dmbaturin: same here
<Drup>
group theory is fun
<whitequark>
huh, the term was invented by Bourbaki!
<whitequark>
I wonder what were they thinking
<dmbaturin>
Fields and field extensions are fun too.
<Drup>
they were french, you can't tell.
<def`>
Monoid are helpful and pervasives in software, it makes sense to keep the notion. Magma is too specific (or general, depending on your point of view)
<Drup>
I agree with def`
<Drup>
and anyway, you don't usually enforce the commutativity in the monoid typeclass (because you can't without proof insertions)
WraithM has quit [Ping timeout: 260 seconds]
<def`>
Monoid doesn't require commutativity
<Drup>
associativity*
<asmanur>
Drup: a magma does not have an identity (it is just a set and a binary operation)
<Drup>
sorry
<def`>
asmanur: 21:29 < def`> and no unit
<def`>
:p
<asmanur>
ah damn
<Drup>
asmanur: slow poke :p
<asmanur>
but i'm looking at bourbaki "algebra 1 & 3" right now so it still counts
<def`>
:)
<Drup>
whitequark: about your remark on + being part of Num and not lists
<Drup>
If you were listening to me, you would have Monoid (with +), Group (with -), Ring (with *) and Field = Num, (with /)
<Drup>
and everyone would hate it, obviously
<Drup>
but I would be happy x)
<whitequark>
open DrupPervasives.EveryoneHatesHim
<Drup>
(and + would work on lists)
<whitequark>
Drup: I understand the sentiment
<def`>
coding is neither about writing mathematics nor litterature. having a small alphabet with unambiguous interpretation is much more important
Kakadu has joined #ocaml
<Drup>
Sure
<def`>
(as the main audience of code is dumb and unforgiving)
<Drup>
I still find that the reason "software engineers hate math" is saddening :(
<Drup>
It's a good reason, but not a nice one
<whitequark>
Drup: everyone hates math
<whitequark>
because instead of teaching math, our schools just instill fear with an incredibly warped version of it
<whitequark>
which has literally zero intersection with real math
<def`>
[that must explain most backtraces I saw today]
<bjorkintosh>
Drup, it's because the ONLY persistent slogan in software engineering is "Worse is better".
<bjorkintosh>
math is not worse.
<bjorkintosh>
so it's bad.
<Drup>
bjorkintosh: <3
<bjorkintosh>
whitequark, why ruin things for the mathematicians? they like what they do and don't want to share.
<Drup>
whitequark: at least, that is something that is true regardless of the nation
<def`>
whitequark: our schools do a similar job here
<Drup>
math teaching is bad.
<whitequark>
Drup: not quite.
<whitequark>
I am saying that it was bad in RU based on my experience
<whitequark>
but after asking how are things in USA, I see that in RU it is actually fucking awesome
<dmbaturin>
whitequark: Read Arnold's papers about french math education.
<dmbaturin>
asmanur: Yeah, looks like it. I read it in russian though.
<Drup>
" Mathematics is the part of physics where experiments are cheap. " https://xkcd.com/435/
<Drup>
the link was needed.
<asmanur>
haha he clashes the ENS
<def`>
"weak need gangs in order to survive" :D
troutwine_away is now known as troutwine
<Drup>
Note that this outdated
<Drup>
it's still bad, but in a completely different way.
nlucaroni has joined #ocaml
<Drup>
and anyway, this treat of quite advanced math teaching already (ENS ...). This is not really where the problem is.
<dmbaturin>
Drup: How bad is it now?
mcclurmc has joined #ocaml
<Drup>
well, the problem is in highschool and beginning of university
<bjorkintosh>
it is?
<bjorkintosh>
it begins earlier.
<bjorkintosh>
too much rote is taught.
<whitequark>
indeed
<bjorkintosh>
so that by highschool, there's no foundation for the other stuff.
<bjorkintosh>
except, more rote.
<Drup>
bjorkintosh: I agree, but I'm not competent for smaller kid teaching :)
<bjorkintosh>
and then it moves on to a calculus sequence...
<whitequark>
math should be taught as the art of reasoning, not the craft of manipulating numbers
<bjorkintosh>
which supports MOAR rote!
<mrvn>
bjorkintosh: that's what you get for multiple choice standardized exams
<whitequark>
fuck standardized exams
<bjorkintosh>
mrvn, well. it's cheaper that way :)
<dmbaturin>
Arnold wrote on school math too, but I'm not sure if a translation exists.
<whitequark>
just burn the whole system entirely and forget it ever existed
<Drup>
whitequark: there is a thing called "prepa" in france, and the first thing the math teacher do, in these classes, is to start back from the very basic stuff. They have to do that because they can't rely on highschool math teaching :/
<whitequark>
define "very basic" ?
<asmanur>
basic set theory / logic
<whitequark>
"basic" like addition? or "basic" like "trivial calculus"?
<Drup>
what asmanur said
<asmanur>
whitequark: they basically do a bourbaki
<asmanur>
they start over from scratch, and prove everything from the bottom up
<dmbaturin>
asmanur: Do they give kids Bourbaki's definition of 1? :)
<Drup>
boolean logic, set theory, building the various number set (N, Z, Q, R) one on top of the other
<asmanur>
dmbaturin: I don't know but we do see Peano's arithmetic
<whitequark>
asmanur: that's pretty awesome
<Drup>
dmbaturin: it's less crazy abstract than bourbaki's
<asmanur>
less modular
<Drup>
I heard university teacher were complaining too, because they changed highschool math program and it's even more poor than before
<asmanur>
the real problem with bourbaki writing style is that it's too modular
<dmbaturin>
Bourbaki's book on the history of math is pretty cool, by the way.
<dmbaturin>
Even if I'm unable to figure out how the finite field it works with is organized.
<whitequark>
you could call it "a war on education" *ducks*
<bjorkintosh>
whitequark, if there are too many smart people in 'murrca, not enough would take the nonsense quietly.
<bjorkintosh>
you want a dumb population, if control is your goal.
<Drup>
bjorkintosh: duh, don't break the american dream.
<bjorkintosh>
yes. quiet.
<bjorkintosh>
people are sleeping.
<Drup>
(not in the USA timezones)
koderok has quit [Ping timeout: 240 seconds]
<dmbaturin>
On a side note, this probably can be used as math equivalent of fizzbuzz problem: http://www.riskliteracy.org/
oriba has joined #ocaml
samrat has joined #ocaml
dsheets has joined #ocaml
mcclurmc has quit [Remote host closed the connection]
thomasga has joined #ocaml
<def`>
dmbaturin: I tried your website, the french version…
<def`>
"Cela signifie que vous avez alphabétisation relativement élevé de risque"
<def`>
I guess it's humor, and quite a good one :)
<dmbaturin>
Hhm, I don't speak french.
<def`>
"It means you have alphabetisation relatively high of risk"
<def`>
Hard to translate as the error is in the translation, but the almost got the correct set of words but put them in the wrong order…
hhugo has joined #ocaml
<def`>
Which is funny in a sentence making assertion on alphabetisation.
<dmbaturin>
By the way, how do the french pronounce acronyms? Specifically, how INRIA is pronounced?
<def`>
It depends on the acronym (actually we make the distinction between "acronyme" and "sigle"… the former being mechanically derived from a list of words, the latter being closer to a brand)
_andre has quit [Quit: leaving]
Thooms has joined #ocaml
<def`>
But for Inria you can pronounce it as if it was a word.
<dorei>
I want to start playing with ocaml, but so far I've failed installing lwt/utop :(