sysop_fb has quit [Read error: Connection reset by peer]
adotbrown has joined #ocaml
Yoric has joined #ocaml
chambart has joined #ocaml
_andre has joined #ocaml
yacks has quit [Quit: Leaving]
yacks has joined #ocaml
ahokaomaeha has quit [Ping timeout: 252 seconds]
adotbrown has quit [Ping timeout: 260 seconds]
hkBst has quit [Ping timeout: 260 seconds]
osa1 has joined #ocaml
hkBst has joined #ocaml
hkBst has quit [Changing host]
hkBst has joined #ocaml
osa1 has quit [Ping timeout: 260 seconds]
hkBst has quit [Ping timeout: 260 seconds]
yacks has quit [Quit: Leaving]
<avsm>
mfp: my strategy there is just to avoid threads as much as i can
<mfp>
avsm: Lwt_preemptive.detach...
thelema has quit [Ping timeout: 276 seconds]
thelema has joined #ocaml
<avsm>
indeed. multiprocess mostly
<mfp>
I mean: "pure" Lwt is much easier to reason with (thanks to lack of preemption) and richer (choose, cancelation, etc.), but given Lwt_preemptive.detach's existence, shouldn't Lwt_gc.finalise do something like the code I pasted by default?
<mfp>
also, you cannot always control/know when 3rd-party code introduces threads for whatever reason
<mfp>
and then all your Lwt_gc.finalise become unsafe
<mfp>
or I'm misunderstanding something... but my hack seems to work
<avsm>
oh sorry yeah; i agree with your assessment that the current finaliser seems broken
mcclurmc has joined #ocaml
<mfp>
also, the need to make finalisers (at Gc.finalise level, without bringing Lwt into the picture) reentrant worries me
<avsm>
like UNIX signals, finalisers probably ought to do as little as possible
<avsm>
set flags really
<flux>
do the 'avoid doing anything'-rules also hold in ocaml?
<flux>
(regarding signal handlers that is)
<mfp>
seems so, but then don't you need a separate thread just to run finalisers in, well about any program with threads?
* mfp
referring to finalisers
<avsm>
java does this, iirc (although you can alter that)
<mfp>
flux: I think so, for sighandlers
<avsm>
flux: ocaml traps the raw signal and jumps safely to them, but there are still demons lurking with threads
hkBst has joined #ocaml
hkBst has quit [Changing host]
hkBst has joined #ocaml
<avsm>
it's safe wrt the runtime
<mfp>
I have finalisers that do x.someset := S.remove bla !x.someset which seemingly is impossible to do safely in the presence of threads :-((
<flux>
wasn't there a way to handle signals the same way all other file descriptors are handled
<_andre>
does anyone have a list of common sources of memory leaks in lwt code? i know that's a pretty vague question but...
<flux>
(in select OSes)
<mfp>
flux: you mean like eventfd?
<flux>
mfp, yes
<_andre>
i have a daemon that is consuming all my memory, and i'm having a hard time figuring out where the leak is coming from
<_andre>
i can't build it with the memprof patch (lwt won't build) and ocamlviz doesn't seem to work
osa1 has joined #ocaml
<_andre>
valgrind shows nothing so it doesn't seem like a problem with C extensions
<mfp>
_andre: here's a problem I've run into a couple times, a pattern like let rec loop t1 t2 = match_lwt Lwt.choose [ t1 >> return `A; t2 >> return `B ] with `A -> ... loop (...) t2 | `B -> loop t1 (...)
osa1 has quit [Read error: Connection reset by peer]
<mfp>
i.e., waiting for the 1st thread to complete, then looping again while reusing all those that didn't finish
tane has joined #ocaml
<mfp>
the problem is that you keep attaching waiters to those that didn't finish, and leak (n - 1) closures on each iteration (until each original thread has finished)
* mfp
brb
<flux>
that's actually quite annoying, I did that when I was starting with Lwt :(
<flux>
I much prefer the way the Event module works, but it's now Lwt
Yoric has quit [Remote host closed the connection]
Yoric has joined #ocaml
yezariaely has joined #ocaml
yacks has joined #ocaml
<mfp>
flux: doesn't seem to help in that use case, does it? AFAIK it doesn't return the events that were not available... in the above pattern, the pb is specifically in the >> return `X which must be performed only once in the tail call as in loop (t1 >> return `A) `B
madroach_ has joined #ocaml
madroach has quit [Read error: Connection reset by peer]
<flux>
mfp, well, it doesn't do synchronization of arbitrary Lwt object but rather only its internal event objects
<flux>
so if you need to synchronize Lwt objects by means other than passing messages between them, it won't help
myx has joined #ocaml
dwmw2_gone is now known as dwmw2
yacks has quit [Remote host closed the connection]
invariant has joined #ocaml
osa1 has joined #ocaml
<invariant>
Is there a function to get the parent id of any parent id?
cdidd has quit [Ping timeout: 255 seconds]
cdidd has joined #ocaml
<flux>
what is parent id?
<invariant>
A PID.
ttamttam has quit [Quit: ttamttam]
<flux>
I imagine it is platform-specific
<flux>
it can be done on Linux via the /proc filesystem
<invariant>
Isn't the idea of a language like OCaml to use the module system to hide these details?
<flux>
maybe there is a library that provides that functionality, I don't know, but it isn't in the standard ocaml library
osa1 has quit [Ping timeout: 260 seconds]
<invariant>
The only other way I see is starting <number of ancestors> processes to get 10 ints.
<invariant>
In short, an overhead of probably 10000 over what it could be.
cdidd has quit [Remote host closed the connection]
<flux>
I thought for a given process id you wanted its parent process id
<flux>
but apparently this is not the case?
cdidd has joined #ocaml
ttamttam has joined #ocaml
hkBst has quit [Read error: Connection reset by peer]
hkBst has joined #ocaml
hkBst has quit [Changing host]
hkBst has joined #ocaml
<invariant>
flux, I would like to have all the ancestors.
<invariant>
flux, I solved it in a different way now. Thanks anyway.
mika1 has quit [Quit: Leaving.]
mika1 has joined #ocaml
ocp has joined #ocaml
hkBst has quit [Read error: Connection reset by peer]
hkBst has joined #ocaml
hkBst has quit [Changing host]
hkBst has joined #ocaml
gnuvince has quit [Ping timeout: 252 seconds]
<Reventlov>
Hello
<Reventlov>
Where can i get the documentation on the zarith library ?
<Reventlov>
I don't want to create an account on ocamlcore to get that.
troydm has quit [Quit: What is hope? That all of your wishes and all of your dreams come true? (C) Rau Le Creuset]
troydm has joined #ocaml
ontologiae has joined #ocaml
tane has joined #ocaml
<orbitz>
Reventlov: I just read the mli, module M = Z
madroach_ has quit [Read error: Connection reset by peer]
madroach has joined #ocaml
tane has quit [Quit: Verlassend]
Yoric1 has joined #ocaml
Yoric has quit [Ping timeout: 264 seconds]
cdidd has quit [Remote host closed the connection]
S11001001 has joined #ocaml
S11001001 has quit [Changing host]
S11001001 has joined #ocaml
cdidd has joined #ocaml
mattrepl has joined #ocaml
Kakadu_ has quit [Quit: Page closed]
ttamttam has quit [Quit: ttamttam]
S11001001 has quit [Quit: ERC Version 5.3 (IRC client for Emacs)]
ontologiae has quit [Ping timeout: 252 seconds]
smondet has joined #ocaml
hto has quit [Read error: Operation timed out]
hkBst has quit [Quit: Konversation terminated!]
hto has joined #ocaml
cago has left #ocaml []
mcsquiggedy_ has quit [Quit: Leaving]
mika1 has quit [Quit: Leaving.]
notk0 has joined #ocaml
<notk0>
hello, ocaml is a meta language right?
<pippijn>
no, it is a normal language
<notk0>
pippijn: what does ML mean tho? doesn't it mean meta language?
<pippijn>
because it's often used to create other languages
<notk0>
pippijn: ocaml is used to create other languages? how come?
<pippijn>
because it's particularly well fit to the task
<notk0>
pippijn: do you know what other languages are made using ocaml?
<pippijn>
coq
<pippijn>
felix
<gnuvince>
notk0: Caml used to stand for "Categorically Abstract Machine Language"; the ML language means "Meta Language".
leoncamel has quit [Ping timeout: 252 seconds]
<notk0>
pippijn: isn't coq used to prove programs and stuff?
leoncamel has joined #ocaml
<pippijn>
amongst other things, it is used to do that, yes
<notk0>
pippijn: those are 2 examples , I don't see how it's particularly well fit for the task
<notk0>
anyway, do you know there is Meta-Ocaml? so it means Meta Meta Language!
<pippijn>
ok
<notk0>
ocaml can be so meta that it's just too much!
<pippijn>
I'm tired, so maybe someone else can explain
<pippijn>
good night
<nicoo>
pippijn: I can try
<nicoo>
Good night
<notk0>
pippijn: it's not even night yet tho...
<pippijn>
1:25AM
<notk0>
acording to wikipedia coq is not a language but software used to prove properties
<notk0>
pippijn: I see, well good night then
<nicoo>
notk0: Meta-OCaml is an extension of OCaml that allow runtime generation of (well-typed) code
<nicoo>
Are you familiar with Template Haskell ?
<notk0>
nicoo: yes, but it's kinda amusing that it's named that way
<flux>
notk0, how does it do it? you say the thing you want to prove out loud and then it does it?-)
<notk0>
no, but if I understand correctly meta-ocaml is like pypy ?
<nicoo>
notk0: Technically, the language in Coq is Gallina; but it *is* a programming language
<notk0>
flux: you write properties
<flux>
notk0, and possibly proof strategies
<notk0>
nicoo: but that doesn't mean that ocaml is more fit and made to write other languages just because coq exists
<nicoo>
notk0: Not at all (for pypy)
<nicoo>
notk0: No, that was an *example*
<notk0>
meta-ocaml does runtime compiling of partial function applications ?
<pippijn>
notk0: do you like ATS?
<notk0>
pippijn: I don't know what ATS is, abstract syntax tree?
<pippijn>
notk0: ok, do you like tup?
<nicoo>
But OCaml is well-suited to this task because 1) it is well-suited to symbolic manipulations 2) its powerfull type-system yields nice static guarantees
<notk0>
don't know what tup is
<pippijn>
ok, good night
<notk0>
ok
<notk0>
nicoo: what do you mean by symbolic manipulations?
<nicoo>
3) It is easy to encode another language inside, in a type-safe fashion
<notk0>
nicoo: encode another language inside as in modify ocamls syntax?
<flux>
and then there were these two web-oriented languages written in ocaml, one static and one dynamic. and who would forget HaXe!
<nicoo>
No; as in define an OCaml datatype « 'a expr » of the language's programms, and write sone interpreter (or compiler) for it
<notk0>
I know there is a compiler that compiles ocaml to javascript
<notk0>
nicoo: but you can do that with any language, ocaml is just functional so you have the match |
<invariant>
notk0, OCaml has fairly high performance tools.
<notk0>
and sum types or how they are call
<invariant>
notk0, they have been tested.
<nicoo>
And « symbolic manipulations » means handling mathematical (or, more generally, abstract) object inside a program.
<notk0>
nicoo: you can do that in any language no?
<invariant>
notk0, all of it can be done in another language and perhaps with even greater performance (C++).
<notk0>
but the syntax is nicer in ocaml?
<nicoo>
notk0: You cannot do it *type-safely* in any language
<invariant>
notk0, the compiler does more useful work per unit time.
<notk0>
ocaml has menhir I guess that is nice
<invariant>
notk0, C++ templates are slow.
<djcoin>
Hey notk0, back trolling on the chan ?
<invariant>
notk0, if C++ had an infinite speed compiler, I would perhaps even use it.
<nicoo>
invariant: Isn't the template system a good enough deterrant ?
<invariant>
nicoo, no
<nicoo>
^_^
<notk0>
djcoin: am not trolling tho
<djcoin>
Right, don't know why I had bad souvenir. Sorry !
<nicoo>
notk0: To come back to why OCaml is well suited for this :
<notk0>
djcoin: probably because of prejudice
<invariant>
If you want a powerful type-system, use Coq.
<nicoo>
1) It has convenient and terse representation of datatypes, like ASTs, intermediate representations, etc
<djcoin>
Probably because of my irc lgos
<djcoin>
logs*
<djcoin>
But i was mistaken
<notk0>
djcoin: good to know
<nicoo>
2) Its type-system yields good static guarantees on your interpreter (or compiler)
<notk0>
nicoo: but this seems more of a functional argument than ocaml one, any language that can do sum types and has match is well suites for ASTs and stuff
<invariant>
nicoo, Haskell's type system is stronger than OCaml's currently.
<nicoo>
notk0: No, because you can encode stronger constraints using GADTs or the module/functor system
<notk0>
hm, a interpreter is dynamic , how can you have a static guarantee? you mean for example a match | plus(Int(i1),Int(i2) ) to guarantee that you have a plus applied on two ints?
<nicoo>
invariant: AFAIK, they have been proven to be equivalent
<invariant>
nicoo, if you use functors in a completely unnatural way, yes.
<invariant>
nicoo, but if you are not allowed to use the module system, no.
<notk0>
I had to do an interpreter and compiler part of my studies and I didn't even know about functors at the time or GADTs
<nicoo>
invariant: There is a world between « using functors in a completely unnatural way » and « not using modules at all »
<invariant>
nicoo, I expect a rank-3 function then in a pastebin :)
<nicoo>
notk0: You can first parse the program to be interpreted, then construct a type-safe representation
<notk0>
to me modules seem "unnatural" in caml, to create a hashmap I have to encapsulate it on a type and I get a module that works with that type right?
mattrepl has quit [Quit: mattrepl]
<nicoo>
And the static guarantee will be stg like « if the program was well-typed (you managed to construct the type-safe repr), then the interpreter cannot stop on a type mismatch »
tac has joined #ocaml
<nicoo>
notk0: You have to encapsulate *what* in a type ?
<nicoo>
All expressions have types ...
travisbrady has quit [Quit: travisbrady]
<notk0>
nicoo: if I recall correctly a hashlist or something in ocaml returns you a module that manipulates hashlists of certain types
<nicoo>
notk0: Hashmaps*
<notk0>
I said hashmap the first time but I assumed It was the wrong name
<nicoo>
It is the right one.
<nicoo>
s/the/a/
<notk0>
ocaml is a nice language but there are stuff from it that I can't seem to accept, I guess it is suited for specific tasks only
<tac>
notk0: like what?
<djcoin>
:)
<nicoo>
notk0: It means that if you know you will be using hash tables with keys of type t, you might want on instance of the right module in you program, like beggining with « module MyMap = Hashtbl.Make(T); »
stephe- is now known as stephe
<nicoo>
notk0: And you might have trouble to accept it because you don't know yet how to use it idiomatically
<notk0>
tac: I never used and particularly liked the objects in ocaml, +. -. *. seems a bit irritating, most objects are immutable and the standard library is used in a way that seems different from all languages I used before
<notk0>
nicoo: exactly, it creates a module, not a hashmap, a module that manipulates objects of hashmaps of specific types
<notk0>
and hashtbl is hashtable no?
<nicoo>
notk0: When you say objects, you mean object-oriented programming ? If so, I also dislike objects; I just don't use them
<nicoo>
notk0: You use the module MyMap as the implementation of Maps with keys of type t.
<notk0>
nicoo: I meant objects oriented , I never made a program in python or ocaml with object in mind, in python it seems wrong, with that syntax of init(__stuff__) and everything else, in caml it seems wrong also
<tac>
notk0: mutability is the reason there is unhappiness in the world
<notk0>
tac: but there are times when you need mutability
<tac>
There are. And there are ways to be mutable, like refs and printfs
<tac>
But think about it
<tac>
Every time you call tech support (or maybe your parents are the ones calling)
<nicoo>
notk0: These are very few and far between; that's why I believe in immutability by default
<tac>
the first thing they ask you to do is restart your computer
<tac>
why do they do that?
<tac>
Answer: because the state in your computer is messed up
<tac>
Mutability means you have to worry about state :)
<notk0>
one cool thing I remember our teacher showed us that impressed me was a red-black tree implementation in ocaml, and how short and understandable the code of insertion-removal was, as you basically matched the structure of the tree and returned a new tree, it was basically it's definition
<nicoo>
notk0: Yes :)
travisbrady has joined #ocaml
thomasga has quit [Quit: Leaving.]
<nicoo>
And immutability means you can safely reuse the common subtrees
<notk0>
tac: but everything is mutable, even if you program in ocaml with immutable types, the state of the CPU, ram, hdd changes, the state of your program changes one way or another etc
mcclurmc has quit [Ping timeout: 276 seconds]
<nicoo>
notk0: You are confusing the programing paradigm and its implementation
<notk0>
nicoo: you made the argument of restarting the cpu :P
<notk0>
nicoo: it's not only about implementation, is that even if your objects are immutable you still modify the behaviour of your program, work with "mutable" data
<nicoo>
notk0: Not me
<nicoo>
tac did
<notk0>
nicoo: you mean your programs always behaves the same, only accepts a single input, and nothing else
<nicoo>
What immutability is about is (in part) the ability to more easily reason about the behaviour of the program
<nicoo>
notk0: Not necessarily
<nicoo>
1) We have multiple input, obviously
<notk0>
nicoo: so your program has dynamic behaviour?
<nicoo>
2) It means that I explicitely know where state is, and what part of the program is responsible for it.
<notk0>
I see
<nicoo>
notk0: I don't get what you mean with « dynamic behaviour »
<notk0>
I remember my teacher shunned me for my last project for not having static guarantees in it, everything was dynamic and only runtime checks
<notk0>
nicoo: I mean that even if you use immutable structures, you still simulate mutability one way or another
<nicoo>
notk0: It is because you didn't use efficiently the type system, if I understand you correctly.
<notk0>
in non-functional languages you would for example add elements to a list, the same list
<djcoin>
With mutability you can never be sure that what the value you hold did not change in some place. And those mutable states is shared accross your whole application, this is a major problem. Besides, if your function etc. have no states, it means they can only act on the arguments they are being to. Thus you clearly know on what they depends
tane has joined #ocaml
<djcoin>
being passed to *
<notk0>
in Ocaml you would either accumulate on the stack, or have a "implicitily" mutable value
<nicoo>
notk0: Again, you confuse PL and implementation
<notk0>
nicoo: when you do a terminally recursive function in ocaml, for example a factorial, you use the acumulator to simulate a mutable value
<nicoo>
What I mean is that most of the code should be state-free, because most of code is made up of functions that perform simple tasks, depending only on input
ahokaomaeha has joined #ocaml
paolooo has joined #ocaml
<nicoo>
notk0: Yes, but you have the guarantee to start each call to factorial in the same state
<nicoo>
And that no input is modified (obviously)
<notk0>
right
* nicoo
leaves.
Cyanure has joined #ocaml
<notk0>
nicoo: do you program in other languages except Ocaml
<notk0>
?
<notk0>
oh right sorry
gnuvince has quit [Ping timeout: 252 seconds]
cfy has quit [Ping timeout: 276 seconds]
ontologiae has joined #ocaml
leoncamel has quit [Ping timeout: 248 seconds]
osa1 has joined #ocaml
ttamttam has joined #ocaml
ocp has quit [Ping timeout: 244 seconds]
gnuvince has joined #ocaml
mcsquiggedy has joined #ocaml
ontologiae has quit [Ping timeout: 240 seconds]
Anarchos has joined #ocaml
mcsquiggedy has quit [Ping timeout: 248 seconds]
ontologiae has joined #ocaml
gnuvince` has joined #ocaml
gnuvince has quit [Read error: Connection reset by peer]
<nicoo>
notk0: Yes, I do
<nicoo>
Mostly C and Haskell
<notk0>
I see
<nicoo>
And Coq
<notk0>
nicoo: did you know that you can make a function inside a function in C?
<nicoo>
I have experience in Java, but I find it painful and will avoid using it whenever possible
<nicoo>
notk0: Yes, I know
<nicoo>
But without closures, it isn't very usefull
<notk0>
nicoo: yeah :P function pointers?
mcsquiggedy has joined #ocaml
<Anarchos>
notk0 yes but be careful with environnement, cause functions pointers are not closures !
<notk0>
Anarchos: I don't remember using them often, I know :P
<nicoo>
Anarchos: Actually, if the functions are pure, you can do fun stuff
<nicoo>
If they aren't ...
travisbrady has quit [Quit: travisbrady]
anderse has quit [Quit: anderse]
mattrepl has joined #ocaml
mcsquiggedy has quit [Quit: Leaving]
ollehar has quit [Ping timeout: 256 seconds]
ollehar has joined #ocaml
tac has quit [Ping timeout: 245 seconds]
ontologiae has quit [Ping timeout: 264 seconds]
tac has joined #ocaml
travisbrady has joined #ocaml
mcclurmc has joined #ocaml
ftrvxmtrx has quit [Quit: Leaving]
travisbrady has quit [Quit: travisbrady]
travisbrady has joined #ocaml
gnuvince` has quit [Ping timeout: 255 seconds]
_andre has quit [Quit: leaving]
emmanuelux has joined #ocaml
ttamttam has quit [Remote host closed the connection]
ocp has joined #ocaml
ahokaomaeha is now known as lolcathost|afk
lolcathost|afk has quit [Quit: When I come back, please tell me in what new ways you have decided to be completely wrong.]
osa1 has quit [Quit: Konversation terminated!]
ocp has quit [Ping timeout: 264 seconds]
notk0 has left #ocaml []
ImAlsoGreg has quit [Quit: Leaving]
mye has joined #ocaml
tautologico has joined #ocaml
anderse has joined #ocaml
ocp has joined #ocaml
anderse has quit [Quit: anderse]
mattrepl has quit [Remote host closed the connection]
paolooo has quit [Quit: Page closed]
tac has quit [Ping timeout: 245 seconds]
tane has quit [Quit: Verlassend]
tac has joined #ocaml
sivoais has quit [Ping timeout: 260 seconds]
jpdeplaix has quit [Ping timeout: 248 seconds]
jpdeplaix has joined #ocaml
travisbrady has quit [Quit: travisbrady]
adotbrown has joined #ocaml
pkrnj has joined #ocaml
chambart has quit [Ping timeout: 252 seconds]
mye has quit [Quit: mye]
ontologiae has joined #ocaml
gnuvince` has joined #ocaml
ollehar has quit [Ping timeout: 264 seconds]
oriba has joined #ocaml
ahokaomaeha has joined #ocaml
mye has joined #ocaml
q66 has joined #ocaml
smondet has quit [Ping timeout: 264 seconds]
cdidd has quit [Remote host closed the connection]
djcoin has quit [Quit: WeeChat 0.3.9.2]
pkrnj has quit [Quit: Computer has gone to sleep.]
nimred has quit [Ping timeout: 244 seconds]
gnuvince` has quit [Quit: ERC Version 5.3 (IRC client for Emacs)]
bitbckt has quit [Quit: out]
darinmorrison has joined #ocaml
dwmw2 has quit [Ping timeout: 245 seconds]
bitbckt has joined #ocaml
bitbckt has quit [Changing host]
bitbckt has joined #ocaml
dwmw2_gone has joined #ocaml
Yoric1 has quit [Ping timeout: 252 seconds]
ocp has quit [Quit: Leaving.]
adrien_o1w has joined #ocaml
adrien_oww has quit [Read error: Operation timed out]
Anarchos has quit [Quit: sleep time]
adotbrown has quit [Ping timeout: 256 seconds]
ollehar has joined #ocaml
sivoais has joined #ocaml
ontologiae has quit [Ping timeout: 276 seconds]
adotbrown has joined #ocaml
Tobu has joined #ocaml
chambart has joined #ocaml
Cyanure has quit [Remote host closed the connection]