1,071 karma · joined January 10, 2010
That pastes with adjust indentation.
Since they show the minimum and maximum we can judge the overall spread, the mean tells us...well...the mean and first and second quartile lets us judge how close data is clustered around the mean.
See http://gnuplot.sourceforge.net/demo/candlesticks.html for gnuplot examples.
In other words, FreeBSD ships with a gcc binary, which means FreeBSD is distributing gcc, which means all clauses in the GPLv3 apply to them.
Any group/company/whatever wishing to ship FreeBSD that doesn't strip out the compiler will be affected similarly.
So do I, which is why I program in Haskell rather than the other languages which make me worry about a ton of irrelevant things like the global state of my program and don't let me enforce invariants of my code in the type system, guaranteeing I can't violate without making the type checker complain.
Switching between the two versions is as easy as making sure that ~/ghc/bin is on my path before /usr/bin/ghc. All I need to do is "export PATH=~/ghc/bin:$PATH" and things work. Packages get installed in either ~/Library/Haskell/ghc-7.4.1 or ~/Library/Haskell/ghc-7.7 depending on what's in my path when I run "cabal install".
How is that remotely relevant? Mercurial is a great DVCS with a user experience that is (in my opinion) far superior to git. SVN on the other hand is...I don't think I need to rehash this tired old DVCS vs SVN argument.
I would love hg support on github, but until that time will use bitbucket for my own projects, perhaps occasionally syncing to GitHub using hg-git.
However, neither license puts restrictions on (end-user) use, which means that as long as you distribute the bits separately, running them together is perfectly fine. Which means (as their FAQ states) that while it can't ship as part of the kernel, there's no reason end-users wouldn't be allowed to load a separately distributed module into their kernel.
If the patch is submitted under the BSD/GPL/MIT license or similar, you are fine. All of those explicitly grant anyone that complies with those licenses to redistribute the patch code (and thus the patched project), with the usual restriction that your license is compatible and that said copyright notice and author names must be reproduced in the resulting entity. Normally you'd maintain an AUTHORS/CONTRIBUTORS files listing everyone's name in addition to the license files. There's no real hard and fast rule for this, though. Keeping the names in the contributed files would also work, for example.
The situation is somewhat murky if the patch writer specifies no license. In this case you are technically not allowed to redistribute the patched code. If the codebase is on github and licensed under some open source license you could (try to) argue in court that that implies the patch is submitted under the same license as the original code, but whether that defense works is up to the judge.
In this sense I suspect the OP would say the same about any ML-like static type system, but not many other static type systems.
IOW, the parent is correct that "speelgoed" pretty much means "goods to play with". I have no knowledge about the Danish leg godt story, though.
Source: Native Dutch speaker
However, the discussion in the link is about encryption, which you want to be fast. A popular webserver serving HTTPS to thousands of clients can't afford a 10x overhead on the speed of encryption.
The use of old P54C core, while understandable from hardware point (design already existed, no need to validate/test) this decision has big consequences. The core can only support a single outstanding memory operation, crippling memory performance. Doubly so because it does not support out-of-order execution, meaning the core is stalled until memory requests finish.
Furthermore, the lack of L2 cache consistency lets you experiment nicely with NUMA and the combination of reprogrammable lookup tables and more physical memory than address space (34 bit vs 32 bit) lets you do nice tricks to share/communicate data between cores with zero copying needed. Unfortunately (due to time/budget constraints) Intel didn't implement any programmable expiration/invalidation/flushing of the L2 cache. This means that any application wanting to use these tricks had no solution beyond reading in a full 256KB (with the proper striding to make sure you actually cache miss on all of those 256KB!) to flush the cache. Such a flush takes approximately 500k CPU cycles, almost guaranteed killing any performance gained from zero copy tricks.
The fact that cores were 32bit is also extremely, as you quickly consume your entire address space when you start playing around with the above mentioned sort of memory shenanigans.
There were some more fairly minor issues, but these are the ones that initially pop in my head.
1. Read abstract. Interesting? Go to 2, else stop reading.
2. Read introduction. Still interesting? Go to 3, else stop reading.
3. Read conclusion. Still interesting? Read the rest of the paper, else stop reading.
The conclusion is there to summarise everything and let people decide whether they want to bother reading the entire thing.