I'd say that solitude (away from all (including online) social interactions) is also a mandatory to-do item once in a while. Just as in-person socializing, it's easier for some people than others.
365 karma · joined August 24, 2007
I'd say that solitude (away from all (including online) social interactions) is also a mandatory to-do item once in a while. Just as in-person socializing, it's easier for some people than others.
Embrace explicit state with state machines and events.
It's very hard to work with people with strongly held opinions, especially when there are more than one such people in your group.
Nah, entries = Arrays.asList(3, 4);
Scala is pretty sweet with a lot of syntactic sugars, but it still it doesn't fundamentally make writing correct code any faster, especially for Java developers who are competent with their IDEs. Until Scala's compile time and IDE support improves 10x, I see no point of using Scala for production code.
Slightly more verbose Java syntax is more than made up by the instant/incremental compilation/autocompletion/refactor that works. Even as a Java noob (I'm more experienced in C++), I can bang out correct code the first time without going through any edit/compile cycles, most of the time. IDE is the new REPL and language snobs always forget that.
The result is a Java++ that's worse than C++. It slows down compilation 10x and makes proper tooling (IDE support) 10x hard, while providing no performance advantages. In C++, you can often get nice abstraction idioms (mostly due to template (partial) specialization, SFINAE) with zero performance penalty.
Java folks should just enjoy the superb IDEs (not just 1 but 3) and look forward to Java 8 or something like that (pending the Oracle issues), which will have a reasonable closure implementation ((JSR-335 looks OK to me), which would make much of the user (vs library/framework writer) side verbosity go away.
People use Java because its stability, compatibility and ecosystem, so C# wouldn't be a viable choice for them but an interesting thing to watch and learn lessons from.
No chrome until noscript.
The main problem of traditional (OLAP) DBMS in the era of big data is that ETL (Extract/Transform/Load) becomes the main bottle neck rather than complex queries, as big data is inherently semi-structured and noisy. MR is the tool to process big data.
I think they dismissed Zookeeper too quickly without trying to understand it first. The zookeeper primitives (get/set nodes and their children) seems simpler and cleaner than doozer is client protocol, AFAICT. Zookeeper should scale better (especially for readers) than typical Paxos based systems as well.
https://issues.apache.org/jira/browse/MAPREDUCE-2399
No XML, no YAML, no config/properties files, no templates. Everything is statically checked by java compiler with instant feedbacks in an IDE. It's better than rails :)
What we need is storage atom/fabric APIs that provide individual namespace (tagging, hierarchical or whatever) and storage (dedup/sync/versioning/replication or whatever) components to enable applications to innovate UX for each domain.
In the next a few years, we shall see the passing of traditional Filesystem APIs and blossoming of new storage APIs.
OTOH, it's a very smart move for G from technical POVs, since their cache hit rate would be much higher as the queries are normalized in greater portion, so that the real impact on their backend is small in comparison (of the overall search volume.)
Haskell code that performs close (within an order of magnitude in terms of run time and space) to its C/C++ equivalent typically is also close in code length (and often less readable!) and often unsafe as well (requires explicit unboxing etc.)
No chrome until noscript, period.
BMZ = bmpack + lzo by default and can be combined with lzma if necessary. It's not really a BMDiff and Zippy clone, as I've never had a chance to see Google's implementation. It's based on the original Bentley & McIlroy paper: "Data Compression Using Long Common Strings", 1999. Even the two pass idea is from that paper. It was really a wacky experimental implementation (with a lot of room for improvement) to satisfy my curiosity. I'm a little surprised that the 0.1 version has been stable for quite a few people compressing TBs of data through it.
No chrome until noscript!
His benchmark is mostly a measurement of Linux kernel thread context switching, which is a lot slower across cores/cpus. I suspect that if he tweaked the Linux kernel HZ to 1000, he'll see another 3-4x improvement.
In most real world servers, the threads are actually doing something real like updating some complex data structure and doing some transformation (encoding/decoding.), etc., which would made context switching overhead less of a problem.
However the benchmark does illustrate the importance of context switching performance for certain workloads.
It's obviously not based on the numbers of watches and forks.
The ~100k files inverted index test is completely unfair to Hadoop: launching 100k map task per small file is ridiculous as it's basically measuring JVM startup time. People/crawlers typically put all these pages in large map/sequence files. Hadoop would automatically launch a map task per chunk (default 128MB).
Fetching data to EC2 for computation is also a step backward. It cannot scale on large data as the cluster will become switch bound much ealier than the "kosher" map-reduce, where data locality is observed.
In any case, it's neither fast or lean (it's basically Java glue code to use S3/SQS/SimpleDB, and seems to have larger overall carbon footprint than Hadoop)