<rixed>
pippijn: I usually use GC cleanup callbacks but it's not always a good idea
<pippijn>
rixed: that doesn't do timely destruction
<pippijn>
it does nondeterministic destruction
<pippijn>
and I need timely destruction
<rixed>
pippijn: you need destruction after a fixed time ?
<pippijn>
in a deterministic moment
<rixed>
pippijn: ok, never encountered this use case in ocaml.
<rixed>
pippijn: I'd probably have a destructor thread waiting for a conditional variable so that the user can destroy everything at once with little fuss
<rixed>
pippijn: but it all depends on the resource at hand I guess
<pippijn>
okay
<pippijn>
well, files are possible with finalisers
<pippijn>
but think about this:
avsm1 has joined #ocaml
svenl has joined #ocaml
<pippijn>
a resource system that is connected to a network server
avsm has quit [Ping timeout: 260 seconds]
avsm_ is now known as avsm
avsm2 has joined #ocaml
avsm1 has quit [Ping timeout: 240 seconds]
<pippijn>
you can register resource handlers
gnuvince has quit [Ping timeout: 244 seconds]
myx has joined #ocaml
<pippijn>
and on registering them, you get a handle to that resource handler
<flux>
there should be a reference-counter-resource-monad!
<flux>
not sure how the increment/decrement would work, though :)
<pippijn>
when you want to unregister the handler, you tell the resource framework to unregister the one associated with the handle you got
<pippijn>
refcounting is kind of what I need, yes
<pippijn>
in some cases, you know exactly when the handler is unregistered
<pippijn>
that would mean the refcount is always 1
<pippijn>
but the people there don't seem to know what SBRM is about, assuming it means lexical scoping
<pippijn>
and lexically scoped resources are easy in ocaml (with_dispose)
<pippijn>
my question is about resources that escape their creation site
myx has quit [Ping timeout: 252 seconds]
<gustav__>
http://www.nyvell.se/tiforum/ <- Site (now) implemented in PHP. I am probably going to port it to OCaml if I get the inclination. A lot of libraries and functions (not meaning OCaml meaning) seems to be work in progress. For example netcgi2. I thought OCaml was an old language? :)
<gustav__>
(Language meaning ecosystem.)
<companion_cube>
it has a relatively small ecosystem, sadly
<companion_cube>
but if you want to write websites, take a look at ocsigen
<gustav__>
Yes, I have but I got stuck. Writing HTML in a special form is tedious. When you want fast results. I know the benefits, but, yeah.
<gustav__>
Rapid, rapid, rapid.
<gustav__>
I've liked/loved ASP/PHP "style" web programming since the beginning when ASP came. I think I was in the beginning...
<gustav__>
I don't really think big PHP documents become/are hard to read... you just have to read it. It's advanced programming...
<flux>
I've many times restarted in ocsigen, and it's always about browsing and browsing manuals
<flux>
not so with Perl & CGI :)
<gustav__>
It's about the easy inclusion of HTML, I think. It's easy in Perl, too. When you just want it done.
<gustav__>
Problem is OCaml has big benefits, too, so you sorta kinda want it too.
myx has joined #ocaml
<gustav__>
Maybe some middle layer...........
<gustav__>
Compute in OCaml -> Post process in PHP...
<gustav__>
But PHP does more than post process. The problem with netcgi2, I had, was it didn't handle parameters correctly/adequately. I think oscigen does.
<gustav__>
I should say templating in PHP.
<flux>
how netcgi2 doesn't handle parmaeters correctly/adequately?
<gustav__>
When I did a GET on a page where I read POST (I do right now, it's online) the GET data disappeared. So I lost that...
<flux>
I've actually done some netcgi2 services, and it's been a relatively similar experience to using Perl CGI
<flux>
hmm, quite strange that GET data could disappear, given it comes in an environment variable
<gustav__>
There's a get_param function, somewhere, I used.
<flux>
my page doesn't appear to use it (but it uses both GET and POST parameters; not sure if it uses them concurrently, though)
<flux>
you can maybe guess that it's a backronym..
<gustav__>
How safe is MD5 nowadays? (I see you use it.) I've recently become aware of MD5 DATABASES, with solved/paired, keys. :)
<gustav__>
Aah.
<flux>
personally, I'm not worried about that password database, but not a bad idea to upgrade it
<gustav__>
Running out of options, sort of. :)
<flux>
a user of this system can change this via irc with a /msg without further authentication
<flux>
actually, maybe I could just open tagging for everyone, even people who haven't authenticated..
<flux>
that's the only service the page currently provides for authenticated users
<gustav__>
If it doesn't take too much resources (storage) or let's user do possibly dangerous (to the system) actions I don't see why there should be authentication. You already get some kind of authentication, I guess... the nicknames.
<gustav__>
"lets"
<flux>
well, in principle adding free tagging would allow spamming the page
<gustav__>
Yes, exactly.
<flux>
and it's not easy to undo that at the moment
<gustav__>
It wouldn't be good idea in #Ubuntu, for instance.
<flux>
in principle2 there is a way to revert operations
<gustav__>
xd
<gustav__>
xD
<flux>
but iirc it doesn't cover tagging operations
<gustav__>
I'm not sure what you mean by tagging. Tag an URL?
<flux>
(there's a log of operations for reverting user netmask merging etc)
<gustav__>
Oh, right, now I see.
<gustav__>
Coding functions in PostgreSQL is a good idea, I think.
<gustav__>
That sort of makes it, at least, more, implementation independent. Like, easier.
<gustav__>
And you know the right thing happens.
<gustav__>
Stored procedures.
<gustav__>
At least gives you an option.
<gustav__>
Options are great.
<flux>
it also can tie you to postgresql, but I'm not kidding myself with being able, or even wanting to, switch databases :)
<rixed>
pippijn: For your problem of resources, I got it now. Unfortunately I don't know of any espacially clever way to handle this. I'd do it à la C (manually unregistering the resources)
<gustav__>
I realised before, what makes SQL so great. It has one write operation, one read operation, one change operation. A SELECT is _ALWAYS_ safe to do. A line of OCaml isn't always as relaxing. You don't always know what's going on behind the curtains. GC, even. Crazy insane stuff! :)
<pippijn>
rixed: :(
<pippijn>
rixed: if the handles can have multiple references, I need to implement manual refcounting?
<flux>
select can actually be unsafe in postgresql.. :-)
<gustav__>
flux: You're not that tied. I think PostgreSQL is pretty standard. Anyway, you just learned one more database. Can always go back to MySQL or whatever.
<gustav__>
flux: Oh man. :(
<flux>
case in point: look at the functions in murmelo.sql.. you call them with select
<gustav__>
Ah, sure...
<gustav__>
A subset, then. XC
<rixed>
pippijn: I would say yes.
<pippijn>
you've never had to handle external resources?
<pippijn>
how do you handle them?
<pippijn>
how do people handle external resources with multiple ownership in ocaml?
<rixed>
pippijn: I'm not doing many client/server progs in OCaml.
<pippijn>
how do you do it in other languages?
<rixed>
pippijn: In C I'd ref count by hand
<flux>
pippijn, if the resource lifetime is somehow non-deterministic, you'd use reference counting
<pippijn>
flux: manually?
<flux>
like in C as rixed says. but c++ and python are able to do it automaticlaly.
<flux>
pippijn, it's not like I have a choice
<pippijn>
sad..
<flux>
and using GC finalizers is not a choice
<pippijn>
indeed
<rixed>
Or you use the GC finalizer to ref count for you, but you have to "flush" it by hand at some point.
<flux>
if ocaml had linear typing, you would be able to guarantee that you properly update the reference count
<rixed>
maybe using a custom block with hand crafter GC cost you can achieve something...?
<rixed>
crafter/crafted
<flux>
rixed, the problem is that it will be called too late
<pippijn>
flux: right
<rixed>
at the next minor heap full event.
<flux>
and if you do GC too often, it will bring your performance down
<flux>
in that time you are able to allocate 1000 file handles
<rixed>
flux: not with the custom block trick
<flux>
boom, otu of file handles
avsm2 has quit [Quit: Leaving.]
<gustav__>
Do any of you have real influence over the OCaml source or is this like out-side speculation and wishing...? :-)
<pippijn>
rixed: custom block doesn't do anything GC finalisers don't do
<pippijn>
in this issue, that is
<rixed>
pippijn: yep but you can ask the GC to finalize your custom block sooner than regular values
<gustav__>
I wonder why I always want to influence a crew of programmers when there's something wrong with something. I could just branch and get my own flavour... Hmm. Must think about that.
<flux>
rixed, how does that happen if GC doesn't even get called?
<gustav__>
But I guess it's nice to get feedback.
* gustav__
talks to himself.
<flux>
you can say that yeah, this file descriptor weights 10 megabytes, it should be release ASAP..
<Qrntz>
I think this can be relevant to your problem
<flux>
but is it a good idea to lie to GC :(
<flux>
I think gc finalizers are only useful for memory-bound resources
<flux>
file descriptors could be one, but sadly they are not in practice
djcoin has quit [Read error: Connection reset by peer]
<rixed>
flux: I agree it's not a good idea to rely on GC, but it's not a very good idea to manually count references either :)
<flux>
rixed, given those two options, though, I choose the latter
<flux>
at least it is deterministic and testable
<rixed>
flux: I'd probably choose tha later also
<flux>
and you can build on them with 'with' kind of constructs. with reference_counter_resource (fun r -> ..) and then deal manually with incr_ref/decr_ref only when you cannot use the resource in a scoped fashion
<gustav__>
I usually set the point to 0 when I'm done and closed and deallocated it. But maybe you're copying addresses.
<gustav__>
point=pointer
<flux>
and it is the scoped way when the GC approach alrady fails
<rixed>
flux: in some other situations (loop) that's the ref counting that fails :-p
<gustav__>
There should be a way to test an address/pointer if it's a valid address.
<gustav__>
That information is available to the OS, at least.
<pippijn>
The requested URL /~fpottier/publis/mezzo-tutorial-long.pdf was not found on this server.
<rixed>
gustav__: there is a function to tell if an address belongs to OCAml heap in the runtime...
<flux>
gustav__, you can see that in Linux. how were you planning to use that information?
<gustav__>
Oh.
<gustav__>
flux: With that I wouldn't need GC or reference counting. :-)
<flux>
gustav__, note that once an address has become invalid, it can become valid again by someone allocating stuff
<pippijn>
got it, thanks
<gustav__>
I could just test the pointer if it's valid. But maybe it could point to some other, formally valid object... I don't know what the API would say about those addresses...
<gustav__>
flux: Right.
<flux>
gustav__, but, I have a solution..
<flux>
we have 64 G address space
<flux>
oops,
<flux>
64 bit
<flux>
just never reuse an address!
<gustav__>
Yep. I know. Exactly.
<flux>
and when it runs out, restart the application
<gustav__>
And at compile time, that doesn't matter. I think...
<flux>
probably a fresh start is good at that point anyway.
<gustav__>
xD
<gustav__>
HAHAHA.
<gustav__>
Oh no, it's one of those 640Kb is good enough for anyone moment.
<flux>
too bad nobody is doing 128 bit architectures
<gustav__>
SSE is 128bit... :C
<gustav__>
Store pointers in SSE! :C
<gustav__>
Wasn't SGI 128bit? MIPS?
<flux>
well, you still don't have 128 bit virtual memory address space
<flux>
I suppose you could do some form of paging
<gustav__>
Exactly.
<gustav__>
Yay, i7 is 128-bit!
<gustav__>
Yaay.
<gustav__>
If I made my own CPU architecture, would it end up on WP, you think? :)
mjonsson has quit [Ping timeout: 276 seconds]
djcoin has joined #ocaml
<gustav__>
Would be crazy to have 128MByte registers. Those would be big.
<gustav__>
Probably slow.
<pippijn>
very slow
<gustav__>
Guys and dolls making processor have probably thought about these things, from a speed approach.
<olasd>
a 128MByte register is (more or less) called a RAM chip
<gustav__>
It should probably be done anyway.
<gustav__>
olasd: Yes, with some language magic, but in reality a register is something inside the processor.
<pippijn>
Qrntz: yes, looks good
<pippijn>
Qrntz: basically dynamic regions
chambart has joined #ocaml
<Qrntz>
pippijn, right
<gustav__>
I bet 64-bit is about how big you can make it, the physical amount of cables, so that you can actually do operations on it in any low amount of time.
<Qrntz>
glad you liked it, it seems like an interesting project
<pippijn>
yes
<pippijn>
sadly, it doesn't exist
<pippijn>
only as a type checker
<Qrntz>
not yet
<olasd>
gustav__: avx does fast operations on 256-bit registers
<gustav__>
:3
<gustav__>
Might be specifically fast in that case.
<gustav__>
In xor operations 64-bit might be better. I don't know? I'm speculating.
<pippijn>
xor is O(1)
<gustav__>
Oh.
<pippijn>
Qrntz: I like it
<gustav__>
I wonder how/where it is O(1)...
<pippijn>
gustav__: xor can be implemented in constant time and linear space
<gustav__>
Yes, but I mean hardware. But sure, that might be it.
<pippijn>
because the bits can all be xor'ed independently
<pippijn>
yes, I also mean in hardware
<gustav__>
That stuff probably executes at the speed of an electron.
<pippijn>
not that fast
<pippijn>
it executes at the speed of the clock
<gustav__>
Hmmm...
<pippijn>
2GHz for example
<gustav__>
Gotta love that clock.
<gustav__>
But the clock blocks it, when it executes it, it's the speed of electron.
<gustav__>
Swooosh!
<pippijn>
not that fast :)
<pippijn>
it still needs to charge transistors
<pippijn>
it takes several electrons to do that
<gustav__>
Okay.
<pippijn>
I guess having large registers helps when you add large numbers
<pippijn>
a carry-look-ahead-adder needs O(log n) time (and n space)
<pippijn>
no
<pippijn>
n log n space
<gustav__>
Probably large registers aren't that interesting. But people look droolingly at larger registers because you can have sooo muuuch RAAAM...
<pippijn>
carry-select needs sqrt n time and n space
<gustav__>
I think people confuse memory with money. Money is good to have. Memory not so sure.
<gustav__>
Those damn economists. Always want more of everything.
<pippijn>
hmm
<pippijn>
2^64 = approx. 1.8446744E19
<pippijn>
how much is that?
<pippijn>
I don't think 64 bit CPUs actually have a 64 bit address space
<gustav__>
18446744000000000000.
<pippijn>
8.796093E12 is the limit, I think
<pippijn>
at least at the moment
<pippijn>
oh
<pippijn>
more
<pippijn>
44 bit
<gustav__>
Is 64-bit enough to address all the data on the planet? Is that how they measure the need, maybe?
<pippijn>
"AMD therefore decided that, in the first implementations of the architecture, only the least significant 48 bits of a virtual address would actually be used in address translation (page table lookup)"
<gustav__>
What does exactly hyperthreading mean? Are they virtual or not?
avsm1 has joined #ocaml
<gustav__>
Does my hardware have 8 cores or 4? :) I remember, 8 are visible to the OS...
<gustav__>
So it's like hardware implemented pseudo multicore... ehm.
<pippijn>
gustav__: hyperthreading means you have twice as many registers
answer_42 has joined #ocaml
<gustav__>
You could maybe say that...
<flux>
including Program Counter registers :)
<gustav__>
But all registers aren't accessible from one program. o_o
<gustav__>
Ehm...
<gustav__>
You ARE crazy.
<pippijn>
HTT is useful for a single process to use multiple cores
<pippijn>
the operating system does that for you
<pippijn>
if it doesn't, your performance will in fact be lower
<flux>
gustav__, the thing is, there is only so many uses for a register in a program. for two programs you can probably find use :)
mye has quit [Quit: mye]
<pippijn>
actually two threads
<pippijn>
if they don't share the address space, hyper threading becomes slow
<pippijn>
(from what I understood, but my knowledge here is 5 years old)
<gustav__>
Cores, not threads, share some cache now. That's promising. Somehow.
<gustav__>
(Not threads mean I don't know.)
<pippijn>
hyper threading does not magically create more processing power
<pippijn>
you know about pipelined architectures?
<gustav__>
Yes, I think so.
<pippijn>
if you have this code:
<pippijn>
a = 3
<pippijn>
b = 4
<pippijn>
c = a + b
<pippijn>
then the first two instructions are independent and can be executed in parallel
<gustav__>
Yeah.
<pippijn>
where "executed" means decoding/scheduling/whatnot whatever the pipeline does
avsm1 has quit [Quit: Leaving.]
<gustav__>
Prefetch, decode, execute.
<pippijn>
and more
<gustav__>
Go for a beer.
<pippijn>
depending on the architecture
<pippijn>
maybe 7 steps
<pippijn>
anyway
<pippijn>
hyper threading simply merges instruction streams from 2 threads
avsm1 has joined #ocaml
<pippijn>
so that you have more independent instructions
<pippijn>
that can potentially be prefetched/decoded in parallel
<pippijn>
got it?
<gustav__>
Maybe.
<gustav__>
It merges?
<pippijn>
thread 1 does this:
<pippijn>
a = 3
<pippijn>
b = a + 1
<pippijn>
thread 2 does this:
<pippijn>
a = 4
<pippijn>
b = a + 2
<gustav__>
AAAH. So it has nothing to do with UNIX threads?
<pippijn>
you can execute these on separate cores
<pippijn>
but the CPU will be idling most of the time
<pippijn>
because b depends on a
<gustav__>
It operates on one program. Got it.
<pippijn>
so it can't load the result from a yet
<pippijn>
gustav__: it does have to do with unix threads
<pippijn>
thread 1 and 2 are real threads
<pippijn>
ok, better this:
<pippijn>
thread 1 does:
<pippijn>
a = 3; b = a + 1
<pippijn>
thread 2 does:
<pippijn>
c = 4; d = c + 2
<pippijn>
hyper threading merges these two threads into a single thread, so it can execute on a single physical core
<pippijn>
because that physical core would be bored by thread 1
mfill has quit [Quit: leaving]
<pippijn>
the pipeline would be blocked by waiting for the result of a = 3
<pippijn>
it could start decoding some of thread 2's instructions
<gustav__>
o_o
<gustav__>
You seem to be mixing a lot. Your threads don't block even.
eikke has quit [Read error: Operation timed out]
<pippijn>
ok
<pippijn>
so let's ignore the threads
<pippijn>
here is a program:
<pippijn>
a = 3
<pippijn>
b = a + 1
<pippijn>
c = b + 1
<pippijn>
ok?
<pippijn>
what does your CPU do here?
<gustav__>
I'm not sure you're an authoritative source. Can you point me to an Intel document, maybe?
<pippijn>
let's say the pipeline is 2 levels deep: prefetch/decode and execute
<pippijn>
gustav__: charming..
Cyanure has joined #ocaml
<gustav__>
Hyperthreads show up as individual processors in Linux, so I think the OS has some kind of multiprocessor access to them, i.e. execute separate programs on them without any kind of mixing. I.e. two streams not having to do with each other.
<pippijn>
ok
<pippijn>
if you think that
<pippijn>
then I'm done explaining
<flux>
gustav__, but its scheduler is able to use that information
<flux>
and apparently there are benefits in doing that
<gustav__>
I think it has more to do with cache. Maybe.
<flux>
that's probably correct. or what kind of other benefits can there be? are page misses faster when the mappings are smaller?
<gustav__>
Are two programs cooperating, with memory access in the same region, SHM, whatever, then that should be kept in the same cache. And it can do that. So that that data can be processed without having to be accessed from RAM.
<pippijn>
it has certainly to do with cache
<pippijn>
but that's a side-effect of what I was trying to explain
<pippijn>
cache misses cause the processor to idle for many hundreds or even thousands of clock cycles
<pippijn>
hyper threading reduces the pain of that by overlaying another instruction stream onto the pipeline
<pippijn>
but you seem to know it better than me, anyway
<pippijn>
so enjoy your knowledge
UncleVasya has joined #ocaml
milosn has quit [Ping timeout: 245 seconds]
<gustav__>
"Hyper-threading is a form of simultaneous multi-threading that takes advantage of super scalar architecture (multiple instructions operating on separate data in parallel). They appear to the OS as two processors, thus the OS can schedule two processes at once. In addition two or more processes can use the same resources." "multiple instructions operating on separate data in parallel" <- WP.
<gustav__>
SEPARATE data.
<pippijn>
that is exactly what I said
<pippijn>
15:52 < pippijn> c = 4; d = c + 2
<pippijn>
15:52 < pippijn> a = 3; b = a + 1
<pippijn>
a and c are separate data
<pippijn>
and the operations on them (+2 and +1) are independent
<pippijn>
so it can be executed in parallel
<pippijn>
MIMD
<pippijn>
superscalar means pipelined
<flux>
while everyone here seems to know what hyperthreading is, here's a simpler example: one cpu, two threads, one thread does integer math, one does floating math, being scheduled 100 ms each. if there's hyperhtreading, both threads can run concurrently, thus within the 100 ms period they are able to use both integer and floating point units.
<flux>
except really it's more fine grained than that.
<pippijn>
yes
Neros_ has joined #ocaml
<gustav__>
Aha. So sometimes, HT processors are concurrent? But mostly not.
<flux>
it depends what you mean by 'concurrent'
<gustav__>
Partial multicore?
<flux>
even single-core non-ht processes are concurrent
<gustav__>
They are operating at the same time.
<flux>
they can do addition on two registers and division on two other registers in parallel
<gustav__>
At the same instant.
<flux>
in fact, that's why modern cpu's are so fast
<flux>
what HT does it feeds those units inputs from two threads of execution instead of one
<pippijn>
flux: they can even do two additions at the same time, if they have multiple adders (which is usually the case)
<flux>
you need go back to microcontrollers to find processors that do only one thing at a time
<gustav__>
;_;
<flux>
what HT does is that instead of picking stuff to feed to the n processing units from one thread of executing (doing just integer math, 50% idle among all cpu units) it can do it from two threads (doing integer math AND floating math, 100% load among all units)
<flux>
of course, the better load among all CPU sub units, the better performance
<gustav__>
So, how many things can my i7 processor do at one single point in time? 1000?
<flux>
probably not quite
<flux>
I'd say at least dozens
<pippijn>
it depends on what "thing" means
<gustav__>
Modify data.
<flux>
if that involves writing to cache or memory, probably only one
<flux>
I don't think you can write many things to memory simultaneously.
<gustav__>
Registers contain data.
<gustav__>
1,2,3,...,64-bit
<flux>
but you can modify stuff in registers
smondet has joined #ocaml
<gustav__>
I could say that thing = word, then. That's a more common definition.
<flux>
that kind of information may not be easily available
<pippijn>
i7 has 14 pipeline stages
<flux>
hmm, although I suppose it must be, for compiler optimization
<gustav__>
O_O
<gustav__>
14 stages per hyperthread... A lot then.
<pippijn>
no, per pipeline
<gustav__>
14 * 2 * 4 = 56.
<pippijn>
ehm
<gustav__>
How many pipelines does a hyperthread have?
<pippijn>
what is a hyperthread?
<gustav__>
Something that fetches instructions from another hyperthread's inputstream and executes it. By your definition.
<pippijn>
a hyperthread is something that fetches instructions from another hyperthead's input stream?
<pippijn>
that doesn't make sense
<gustav__>
That's how I understand what you explained above.
<flux>
apparently there are "36 Unified Reservation Stations" in nehalem architecture, not sure if it's the same as execution units
<pippijn>
it seems my explanation was bad
beginner42 has joined #ocaml
<beginner42>
how can i include a module inside a signature?
<gustav__>
I like this computer. I can run FAH, a virtual computer and play HoN at the same time and HoN works flawlessly... it's crazy.
<gustav__>
flux: :O
<gustav__>
I have Lego Mindstorms actually. Not the same thing, I know.
<flux>
well, nans2legominstorm then :)
<flux>
I actually have a lego mindstorm as well, got it from my friends as a graduation gift
<flux>
did a robot I could control from pc (with ocaml :)) but that's it :(
<gustav__>
:)
<gustav__>
I made a radar with mine.
<flux>
it had a radar, yes :)
<gustav__>
Not with OCaml but Java.
<gustav__>
Nice. :)
Xizor has joined #ocaml
<beginner42>
Qrntz: yes, if i remove the mli file it compiles. and yes
<gustav__>
I have a lot of mind hurdles to get over before I can use it properly, I think.
<Qrntz>
weird
<Qrntz>
beginner42, what's the referenced module and how do you build?
<flux>
gustav__, but I really suggest you going through a course/book something like that. even if you aren't able to design an i7 when you finish it, you should have a much better understanding how things go together.
<flux>
beginner42, maybe it would help if you were able to put stuff you have online
<flux>
github gist supports multiple files
<gustav__>
flux: Yep. I try to look at all courses I can find, online.
<flux>
gustav__, you don't need all, you need one good one :)
<gustav__>
MIT OCW, Yale OYC, Harvard has some videos you watch from the beginning of the courses when the students aren't registered. :3
<gustav__>
flux: Yeah, an optimized product. It's hard to know what that is, especially for me. I watch A LOT. Read as much as I can... well.
<gustav__>
It's hard to keep up engagement all the time. If that's the correct word.
<flux>
gustav__, also, keep in mind what they say about mathematics: it's not a spectator sport :)
<gustav__>
Right.
<gustav__>
I think it mostly is though. Like with OCaml... but yeah, not 100%. But it's hard to do math on the computer. Paper is so damn annoying and depressing.
<gustav__>
I more believe in programming the brain with as much input as possible.
<gustav__>
I let different sources compete. TV and lecture for instance. There's a lecture on TV.