dzderic

A large young gen makes sense since it reduces the frequency of minor GCs but doesn't affect the duration of them, since the running time of a young gen GC is only proportional to the amount of live objects.

For anyone who has ever battled with maintaining their own apt/yum repos, this seems like a godsend.

The most-used tools for getting a package into your repo involve scp'ing the file to the repository server and running a command to update its index. It's nice to have a proper toolset to do this, but it's too bad I spend most of my time with YUM nowadays.

This "solution" will only make it harder for regular folks to execute orders, since HFTs will beat the randomness by shooting multiple orders through multiple order gateways.

You should be able to recreate that 1D scatter plot using a regular scatter plot and setting all of the y values to 0 (unless I'm missing something).

Even better, [1] == 1 but [1] != [1]

When you're talking about an average latency of single digit us for a regular switch and < 500ns for a low-end performance switch, the difference between 10 and 20 microseconds is massive.

The example cited here is insulting to everyone's intelligence:

  The possibility of representing face cards with a name would likely never occur to you, because it would be too complicated to go through the effort of defining the type of a rank to be a "integer or a class comprised of four case classes -- jack,queen,king,ace".

I'm sure every competent Scala developer will see that the equivalent in Clojure can be done with val King = 13; val Queen = 12; ..., which also means you get ordering for free as you're not mixing ints and keywords.

I do agree with the author's point that Clojure almost forces you to adopt a simpler design, but I feel that long-term maintainability requires a delicate balance of simplicity and structure that can be achieved with Scala, but takes more self-control with Clojure.

A while loop and temporary mutable variables are definitely not the Pythonic way of doing this. More idiomatic:

    $ time python -c 'print sum(xrange(100000000 + 1))'
    5000000050000000
    
    real    0m1.398s
    user    0m1.383s
    sys     0m0.012s

Comparison to baseline:

    $ time (echo -e 'n=0 \ni=0 \nwhile (i <= 100000000): \n  n += i \n  i += 1 \n\nprint(n)\n' | python)
    5000000050000000
    
    real    0m33.140s
    user    0m32.939s
    sys     0m0.023s

After finishing the Cousera crypto course, I did a quick review of their approach and found 2 issues which completely broke their authentication protocol (https://github.com/saltstack/salt/issues/2239 & https://github.com/saltstack/salt/issues/2916).

What kind of performance are you getting, and how many nodes do you have?

Does anyone have any experience with F# (and Mono in general) under Linux? How's the library support?

It seems like it should be a good fit for the stuff we normally do (log processing/munging), but I don't know how well it'll work outside of Windows.

It is a fairly comprehensive reference and all, but saying 'sed Editor' is just as bad as saying 'ATM machine'.

I'm in the same boat as the OP except I'm just about to finish high school with 2 years of part-time experience in a web dev shop.

The main problem I'm having is not even being able to land an interview. Where should I look for a dev job in Australia?

Since when was Javascript slower and less useful than Python and Ruby? V8 has made JS one of the fastest interpreted languages and it is one of the most used languages around (you're running it right now!). Also, node uses libev for its event loop, not some 'hand-rolled' one.

Try something like OpenVPN which uses UDP, which in my experience is much faster than a SSH tunnel.

I'm pretty sure it's a string method so it can take any iterator as an argument.