Ashwin Jayaprakash's Blog

Kotlin, Unix Philosophy, Cypher and loads of tech stuff to read

2012-01-28T21:13:00.000-08:00

There are so many JVM based languages out there and yet none of them seem to be able to take over from good old (has it really been that long) Java. From my point of view (I'm sure it's shared by many others) most of these languages like Scala, JRuby, Groovy, Gosu, Clojure, Ceylon etc feel too far away from the center. They either propose radical syntax and idioms, seem overly clever, too flexible and hence not clear/safe for the average developer, or just not performant enough.

Take Scala for example. If you pay no heed to the sensation Yammer's leaked email to TypeSafe caused and just read between the lines, there are some very real truths there about what a large population of developers, team leads, managers expect from a language before they can invest time, training, money, people and their careers into it.

Which is why, I find JetBrain's Kotlin and to some extent for non-server side Google's Dart to be promising. Neither of these languages are about revolutionary/radical new concepts or "paradigm" shifts (ahem) nor do they hide their Java roots. Dart is definitely not JVM based but neither is Kotlin planning to stick to just the JVM (LLVM plans). They are both intended to be evolutionary cleanups with some state of the art language features.Only time will tell if they succeed.

To add to our distractions we have Node.js with some appeal if you are just out of school and easily impressed or have a very specific need. Sigh...I'm already sounding like a weather beaten veteran who's seen too many "flash in the pans".

If you didn't know and are wondering what the actual JVM team has been doing in response to the demand from these new JVM-based languages in Java 7, here's a hint (JSR 292, MethodHandles, InvokeDynamic ..). Be warned, this is not for the faint of heart.

Enough of that. Now on to BloomFilters, a wonderful data structure heavily used by all NoSQL systems like Hive, Cassandra etc. Here's a very nice visualization.

I've written about Neo4J the graph database before. I really like the concept but I haven't found an excuse yet (partially because it's LGPL) to use it. They even have a nicely done graph access language, sort of like SQL for graphs called Cypher. Here's a nice demo of Neo4J, Gephi and spatial data. Makes sense for desktop use but I don't know if they have many server/enterprise grade users with many concurrent transactions.

If you are looking for some general tech reading, like while on a place, here's a nice set of essays (also a book) - The Architecture of Open Source Applications.

Speaking of Open Source, I had not read or heard about The Unix Philosophy. I like the simplicity and focus. Obviously it has had great success but it applies to other software too. Sort of like Deiter Rams ideas on design but for software.

If you've made it till here and are dying for some hard core tech, then here's some on CAS concurrency, Azul's proposed Linux kernel patch and thread affinity.

These days, any blog is incomplete without mention of BigData. So, here's some BigData reading material - slides from the Cassandra 2011 summit.

Ashwin.

An 8 day, 3228 mile long road trip

2012-01-02T11:11:00.000-08:00

We did an 8 day, 3228 mile long road trip from the Bay Area to Arizona, New Mexico, Nevada and back via Los Angeles. A proper road trip with just a rough idea of our route, no prior hotel bookings, a rental car and friends.

View Trip/Dec2011 in a larger map

Until next time!

Some interesting talks from Camelone, Eurocon, HadoopWorld, distributed joins and more

2011-12-03T20:32:00.001-08:00

Apache Camel, if you haven't used or even heard about this lovely little integration framework then I highly recommend watching this video by one of its founders. It's best described as a mini-ESB, an implementation of the Enterprise Application Integration Patterns (EAI) with API/programmatic access, a zillion connectors and a delight to use.

Also worth watching is the EAI intro video by Gregor Hohpe at Camelone 2011.

Some interesting HadoopWorld 2011 slides:

Apache Eurocon 2011 slides, worth reading - Lucene at Twitter.
Joins - the Achilles heel of NoSql, distributed systems. Possible, but difficult and not always feasible. Yet, several solutions are available being offered in addition to the big data warehouse vendors and do-it-yourselfers.

More lessons on IO - Disk I/O abstraction layer X-rays.

You thought System.nanoTime() was fast than using System.currentTimeMills() for profiling? Well.. it's all relative.

The old JCache API seems to have been revived - JSR107: The new Caching Standard. It's also going to be a part of the next JEE spec. More signs of commoditization - a good sign of progress.

Until next time!

Garbage collection, memory, IO and other scary stories

2011-10-31T20:07:00.000-07:00

Happy Halloween! Want to read some scary, low-level, systems related stuff? Here's a short list of very useful articles I read recently:

SQL anti-patterns.

GC horror stories in the .Net world.

Still not scared? How about some math and statistics:

Ranking data at LinkedIn
Some more math stuff and other useful miscellaneous Java articles
Basic R/statistics every programmer should know

Boo!
Ashwin.

Hiking in Fremont Older Open Space Preserve

2011-09-24T17:15:00.000-07:00

So close to South Bay Area. Prospect Road trail is a little steep but short. Worth visiting again because there are so many trails.

2011-09-13T09:01:00.000-07:00

Monday = one of the days of the week when you forget if you had coffee and have to look in the trash can for the discarded coffee cup, just to check.

Offloading data from the JVM heap (a little experiment)

2011-09-13T05:25:00.000-07:00

Last time, I wrote about the possibility of using Linux shared memory to offload cacheable/reference data from the JVM. To that end I wrote a small Java program to see if it was practical. The results were better (some even stranger) than I had expected.

Here's what the test program does:

Create a bunch of java.nio.ByteBuffers that add up to 96MB of storage
Write ints starting from the first buffer, all the way to the last one - that's writing a total of 96MB of some contrived data
For each test, the buffer creation, writing and deletion is done 24 times (JIT warm up)
For each such test iteration, measure the memory (roughly) used in the JVM heap, the time taken to create those buffers and the time taken to write 96MB of data
Obviously, there are things here that sound fishy to you - like why use ByteBuffers instead of just writing to an OutputStream or why write to the buffers in sequence. Well, my intentions were just to get a ballpark figure as to the performance and the viability of moving data off the JVM heap

About the test:

There are really 5 different ways to create the buffers. Then there are 2 variations of these tests in which the buffer sizes vary (blocks), but the total bytes written are the same
The buffers (blocks) for each variation are created as:

Ordinary HeapByteBuffers inside the JVM heap itself - as a baseline for performance
DirectByteBuffers
A file created on Ext4fs using RandomAccessFile and parts of the file are memory mapped using the FileChannel. The file is opened in "rw" mode. Other options are "rwd" and "rws"
The same as above but the file resides in /dev/shm the in-memory based, shared memory virtual file system (Tmpfs)
The buffers are created using Apache's Tomcat Native Libraries which in turn use Apache Portable Runtime libraries. The Shared memory (Shm) feature was used to create the buffers. This is similar to DirectByteBuffers but the buffers reside in a common area, in OS memory and not owned by any but shared between processes (Similar to /dev/shm but without the filesystem wrapper overhead)

The machine used to test was my moderately powered Windows 7 home laptop with 8GB RAM, 2.3GHz i5 running a Cloudera Ubuntu Linux VMWare Player. There were a few other processes running, but nothing that was using CPU extensively. 500MB+ memory was free and available
The VM had 1GB RAM and the JVM heap was 256MB

Results:

The test program was run once for each configuration, but each test itself ran 24 times to allow the JIT to warmup and even the file system caches to stay warm where needed
The test prints out the timings with headers which were then compiled into a single text file and then analyzed in RStudio

summary_mem_used_time_taken_millis

  block_size                      test_type perctile95_buffer_create_and_work_time_millis perctile95_mem_bytes
1       4096                         direct                                       1555.65              3047456
2       4096 file_/dev/shm/mmap_test.dat_rw                                        661.70              3047632
3       4096          file_mmap_test.dat_rw                                       2055.75              3047632
4       4096                           heap                                       1071.15            102334496
5    4194304                         direct                                        653.85                 3008
6    4194304 file_/dev/shm/mmap_test.dat_rw                                        561.40                 3184
7    4194304          file_mmap_test.dat_rw                                       3878.25                 3184
8    4194304                           heap                                       1064.80            100664960
9    4194304                            shm                                        678.40                 2496

Interpretation of the results:

The test where block size was 4KB had quite a lot of memory overhead for the non-Java-heap ByteBuffers. Memory mapping was also slow for these small sizes as the Javadocs itself says for FileChannel.map()
The JVM heap test was slower than I had expected (for larger ByteBuffers). I was expecting that to be to fastest. Perhaps it was the small memory (1GB) virtualized OS it was running in. For smaller block sizes approaching 1K or less, the JVM heap performance is unbeatable. But in these tests, the focus was on larger block sizes
The Apache shared memory test would not even start for the 4KB tests as it would complain about "not enough space"
Almost everything fared well in the larger 4MB test. The per-block overhead was less for the off-heap tests and also the performance was nearly identical for /dev/shm, Apache Shm and DirectByteBuffer

Sources:

The sources for this test are available here.
To run all the tests except Apache Shm you only need to compile JavaBufferTest and run it with the correct parameters
To run all tests, you can use the sub-class AprBufferTest which can test Apache Shm and also the remaining tests. To compile this you'll need tomcat-coyote.jar from apache-tomcat-7.0+. To run this you'll need the Jar file and the Tomcat Native bindings - tcnative.dll or libtcnative for Linux

There are advantages to using ByteBuffer outside the Java heap:

The mapped file or the shared memory segments can outlive the JVM's life span. Another process can come in and attach to it and read the data
Reduces the GC pressure
Zero-copy transfers are possible to another file, network or device using FileChannel.transferTo()
Several projects and products have used this approach to host large volumes of data in the JVM

Disadvantages:

The data has to be stored, read and written using primitives to the ByteBuffer - putInt(), putFloat(), putChar() etc
Java objects cannot be read/written like in a simple Java program. Everything has to be serialized and deserialized back and forth from the buffers. This adds to latency and also makes it less user friendly

Misc notes and references:

These tests can also be run on Windows, except for the Linux Tmpfs tests. However a RAM Drive can be used to achieve something similar

Ashwin.

Blue Lakes and Clear Lake (CA's biggest natural lake)

2011-09-06T21:07:00.000-07:00

Clear Lake in Kelseyville is a nice and peaceful place to visit and spend a weekend. Unlike Tahoe this feels cozier, less commercialized and is close to Napa. You can rent lake front property/spacious homes, relax and unwind. It is also the largest natural freshwater lake entirely in California (Tahoe is not because it spreads into Nevada).

Blue Lakes is a smaller lake about 45 minutes from Clear Lake (Soda Bay) and is a perfect spot to float around on the lake and spend a warm afternoon with family and friends.

View Trip/05Sep2011 in a larger map

Ashwin.

RAM disk is already in Linux and nobody told you (a.k.a Shared memory for ordinary folk)

2011-09-01T00:26:00.000-07:00

The Linux 2.6 Kernel these days comes with an in memory file system. This is really shared memory across processes ("Everything old is new again!").

The beauty of the Linux implementation (like everything else) is that this shared memory looks like a regular file system - /dev/shm (but is really Tmpfs). So, your application - yes even a Java application can use this shared memory system across processes as if it were just writing to a regular file. You can create directories, setup a memory quota for this file system, tail files, change to the directories etc like any other directory, open-write-close files that can be read by other processes. Convenient!

RAM disks are not a new concept. But a RAM disk driver that is built into the kernel adds a totally different level of credibility and trust to the concept.

All the contents of this directory are in memory. Nothing gets written to the disk, no flush, no IO wait times. Naturally, this being in-memory you will loose all the contents when your OS reboots. What possible use can this be to us, I hear you ask? Well well.. where do I begin:

Memory is cheap. 96GB RAM is quite common these days on server class machines
You can run a big RDBMS on this file system. Typically these databases are anyway replicated/clustered over the network

So you can run the entire DB in-memory and still have HA because the replica is running on another machine anyway (low "disk" latency + high TPS + HA)
Why write to a local disk which can crash anytime
Why spend so much on expensive SSDs
10GigE is already here

Run medium sized JVMs and push all the heavy data to this shared memory filesystem

You free up the heap to do simple in-JVM caching and reduce the pressure on GC by moving all the data to /dev/shm
If your JVM crashes, another JVM can be notified to pick up that data since it is just stored as a bunch of files and directories

People used to do IPC all the time using old fashioned shared memory constructs but it fell out of favor because networks and network drivers became quite fast

Also moving away from IPC to TCP-over-localhost gave you freedom to spread your processes across machines (TCP-over-GigE)
Perhaps it is now worthwhile to re-examine that approach and shave precious milliseconds by not copying data back and forth between processes over sockets

To that end I wrote a simple Java class to measure the performance of writing to file on /dev/shm compared to a regular disk based file on /tmp. The results are interesting and I'm hoping will make you readers re-think about your software systems ("Everything old is new ...").

The program is a simple Java file writer that forces a flush every few tens of bytes (which means nothing when writing to /dev/shm). The destination file and its path can be specified as a command line argument. So, it's easy to compare performance. I ran these tests on a Cloudera-Ubuntu VMWare image running on my 64-bit Windows 7 laptop with 4GB RAM and 2.3 GHz duo core Intel i5. In-memory is not surprisingly 7x faster for a 112KB file. Also, laptop was running on batteries means processor speed steps down to save power.

Why people do not talk about this relatively new Linux feature out loud is perplexing.

Other interesting commands you can run against this file system:

mkdir
cat
tail, grep
ipcs -a
df -k

Follow up articles:

Detailed log:

Until next time,
Ashwin.

Guicing up your app with Google Guice

2011-08-28T23:22:00.000-07:00

I've created a simple but not completely trivial demo application using Guice. This is something I did to understand and compare Google-Guice with JBoss Weld's CDI RI for Java SE.

This project is a pure Guice project called Guice-Demo (duh) . Here's the source. Well, that's all there is. I thought this would be of some use to other first time users. The project wiki/docs are minimal and I might add some info later on, when I have the time. Until then I hope that the code is self explanatory.

If you are interested in the Java CDI standard, then this is useful. Weld also works on JavaSE but has no control over classpath scanning for injection and makes starts up times slower and somewhat wasteful.

Guice's module creation is very straightforward. It also allows creating multiple Injector instances.

Both Weld and Guice are not very unit test friendly as you will see here.

Ashwin.

Hiking in Stevens Creek County Park

2011-08-27T18:28:00.000-07:00

Accessible and a relaxing walk around the reservoir that can easily convert to a longer hike. It's surprising that I had never been to this place, less than 15 minutes away. Avoid the main entrance on Balboa road which requires a fee to park. Try the West campus entrance where street parking is allowed (looked like).

There are 2 adjacent parks that are probably worth visiting as well.

In-memory DB tables, shared nothing, time series, low latency and others

2011-08-13T11:43:00.000-07:00

Some useful articles I read in the past few weeks.

Big data, shared nothing, distributed SQL, in-memory SQL:

Realtime hadoop usage at Facebook
Teradata

Teradata Shared Nothing storage
Teradata compared with Oracle Exadata
Slightly dated but comparison doc between Teradata and Oracle

Apache Derby's tuning docs
MySQL's in-memory DB options

New age time series databases:

Very good and detailed accounts of low latency Java based servers:

Disk I/O and time related notes.

Programming and Java:

Until next time,
Ashwin.

Java 7's j.u.c.Phaser - a short tutorial

2011-08-01T20:43:00.000-07:00

If you've tried to figure out how the Phaser works in Java 7 and haven't had much luck, then you are not alone. I too had some difficulty understanding what looks like a very esoteric concurrency construct. I asked around on the Concurrency-Interest forum. Folks there are very helpful and I almost understood it but was missing some details.

So, I decided to get my hands dirty and play with this new toy. Phaser (as the JavaDocs say) is very much like a CountDownLatch or a CyclicBarrier but is better suited where:

Parallel operations need to proceed in lockstep
After every step, all parallel operations wait until all others have completed
When they do, all proceed to the next step and so on...

Sounds easy, but understanding the API was not easy for me. So, I had to write a simple program to see how it worked. Here it is:

What the program does is:

Create a Phaser instance and set it up to expect 2 parties and the main thread/itself as a third party
Start 2 producer threads
Start a consumer thread
Unregister itself as the third party and let the 2 producers run in parallel - as 2 remaining parties
In the mean while the 2 producer threads pretend to do some work and move forward in phases

There are a total of 10 phases
Each producer writes it results into an array where the array position matches the phase number
I call this array per producer - a lane (like a highway)

While the producers are running, the consumer tries to catch up with them

It waits for the phase to complete and then reads the results of that phase
The consumer is slower and over time it trails behind the producers
When it comes back after pretending to do some processing the producers would've moved - sometimes 1 or even 2 phases ahead
The consumer now reads all the phases that have completed so far and then catches up

This consumer looks like it is reading "read-committed" transactions - doesn't it?

This picture (hopefully) explains more clearly, what is happening in the code:

(Remember - the sequence diagram and log shown here are specific to my computer. On slower or faster machines you might see slightly different results - for the consumer, at least in the beginning phases.)

The log output:

Until next time!

Java 7 (the good bits)

2011-07-31T13:14:00.000-07:00

Finally, it's here!

Like you, I've been waiting for this release for almost 3 years. Sometimes wondering what features would really go into version 7... sometimes wondering if there would even be a 7 (after the acquisition).

Here's the smallest set of links that you'd need, to understand the new features. Of course there are many articles and blogs on the internet with more detailed information:

The most obvious - release notes
The map of the Java SE world

Performance enhancements
Concurrency changes - Phaser and Fork-Join

I would suggest using this animated framework to ease your understanding

NIO enhancements

More detailed NIO.2 code examples
Slightly more detailed articles - #1 and #2

Multi language support
The rest of the features and fixes

Enjoy!

Review of EJB 3.1 Cookbook

2011-07-28T18:38:00.000-07:00

I just finished reading the EJB 3.1 Cookbook by Richard M. Reese. I haven't used EJBs in almost 5 years and since the JEE spec hadn't undergone any major (interesting) changes I had ignored it....until I heard about the newer and more simplified JEE 6/EJB 3 spec - the one that uses Java annotations. To me this attempt to simplify the standard seems like a very good thing in that the standards body finally started paying attention to the many accusations hurled (rightfully so) upon it my Spring, Ruby/Rails, Scala and other camps.

So, I was curious to see what the new spec looked like and coincidentally I was given a chance to review this EJB 3.1 Cookbook by Packt Publishing. The book being a cookbook/recipe book, it does not go into the details of why you should use JEE/EJB or how a beginner should get started and other such basics. It assumes that you are already familiar with programming, Java, JEE and specifically EJBs.

I must say that the new spec looks lighter and so much simpler than it did a few years ago.

The book is packed (no pun on the publisher's name) with small and useful recipes focusing on each new aspect of EJB 3.1:

Dependency Injection (CDI)
Stateful, stateless and singleton EJB annotations
Persistent EJB annotations
MDB annotations
Timers and schedulers
Concurrency
Startup sequence, named and dependent EJBs
Soap and restful web services
Security
Interceptors (AOP)

It is a good book to help you get up to speed on the latest spec. You might still, occasionally need to look up the detailed spec or Google or some other forum for specifics. Overall it is a good, almost vendor agnostic (Oracle Glassfish) and easily digestable read. It does lack some depth in a few places but then if you need more details, then you should read the actual spec.

As an aside, I feel all publishers should reduce the prices of their ebook/PDF versions.

Until next time,
Ashwin.

2011-06-29T19:14:00.001-07:00

60F and raining... somebody forgot to switch on Summer.

The Five W's (and H) approach

2011-06-25T12:17:00.000-07:00

A few days ago, I was trying to explain some technical concepts to a friend. After a bit of explaining I tried listing out reasons, places and times where those concepts would be applicable. I still thought that I had left out something. I then spent some time searching online for ways to - learn systematically and teach correctly by at least outlining the essentials of the problem and encouraging the learner to follow up in his/her own time.

Did I find anything? Of course I did. In fact I discovered too much information but found only some to be simple and interesting. My favorite is what you might think is obvious - The Five W's and an H approach.

Apart from it being obvious, the Five W's helps you to break down the problem into:

When
Where
What
Who
Why
How

The easiest way to teach this to kids is to use each finger on one hand to stand for a "W". The H is extra.

Now, why is this simple technique relevant?
    It is:
        Simple
        Easy to remember
        Easy to explain

    It serves as a starter guide to:
        Formulate the right questions
        Break down the problem
        Cover/analyze all aspects of the problem - like why & why not, what & what not

    It also helps us:
        Remember better by understanding, instead of memorizing
        Identify the problem by looking for signs (5 Ws)

    It works quite nicely as:
        A way to exchange ideas (5 Ws = 5 aspects)

        A way to encourage people (even kids) to think deeper- (Systems thinking)
            By supplying the first 5 questions when stumped
            Progress to other approaches

        A template to share and disseminate knowledge (5 Ws = 5 steps)
            Like Design Patterns and Anti-patterns for software design
            Simple reproducible steps for QA/Support/Services/junior members etc.

Here's a simple pictorial way to help you get started. I drew it for myself initially. It is built like a form where you can fill in the blanks, on the right hand side. I encourage you to print it out and use it in meetings too or even to teach your kids.

The 5 W's and H extended

Until next time!

Sharding, distributed object graphs and other reading material

2011-06-18T11:23:00.000-07:00

[Minor update: June 20, 2011]

Some interesting notes on sharding/data partitioning using SQL:

Database sharding at netlog with MySql and PHP
Distributed Set Processing with Shard-Query
Data partitioning - scaling database
Some previously described here

But, these are more interesting - notes on designing a complex, distributed, object graph:

Beyond the Data Grid: Coherence, Normalisation, Joins and Linear Scalability
Avatara - LinkedIn's home grown OLAP
Some previously described here

I came across ActiveJDBC (yeah yeah.. I know what you are thinking.. another ORM) but this is simple and only aims to solve the simple (80%) cases. Very unobtrusive.

Some IO related system internals:

Interesting article about mmap and Linux O_DIRECT
VMtouch - finding how many pages of your file are cached

A detour:

What goes on behind the (IT) scenes in an Investment bank?
An interesting talk on Re-thinking IT by John Seddon a Systems thinker

Until next time!

Some tools you should not leave home without

2011-05-19T21:35:00.000-07:00

In no specific order:

After years of searching for hierarchical to-do list managers, frustrating outline and OPML editors, buggy project trackers I found this - ToDoList. It's clean, free (as in speech) and surprisingly, has really nice features
yWork's brilliant diagram editor - Graphity or it's thick client cousin - yEd
XMind for mind mapping and brainstorming
A decent screen capture and annotation tool - Screenpresso
Notepad++, naturally

Hiking up Mission Peak

2011-05-08T12:18:00.000-07:00

The best time of the year to go there - Spring. Preferably, to watch the sun rise or sun set.

DSLs, OODBs, system internals and some Java stuff

2011-04-28T11:01:00.000-07:00

DSLs:

Groovy is perhaps the best language that lends itself for this purpose. Here's a nice (longish) introduction - Groovy.DSLs (from: beginner, to: expert)
A simpler pseudo DSL based on regex - Jbehave, primarily used for Behaviour-driven development in Java

A good article by (The) Martin Fowler on how to develop quality code - for beginners.

A few good articles I came across recently on operating systems, disks, networking:

OODBs - NoSql's grandpa and the forgotten cousin of SQL. Haven't even heard of OODBs? Here's a 4 year old article but still worth reading.

Java tidbits:

NIO ByteBuffer related memory de-allocation problems

The problem
Also a documented Sun/Oracle bug
Solution 1: https://github.com/toddlipcon/hadoop-lzo/commit/91cf4d921f1f247bf764f3d1ef5df831ca8f465f
Solution 2 also done by FileChannelImpl.unmap(xx) - line 724

ObjectOutputStream's ClassLoader limitation
The many uses of Sun/Oracle Java's Unsafe API and a clean way to get hold of it

2011-04-20T21:28:00.001-07:00

You know you are growing old(er) when you catch yourself listening to the news more often than music, while driving.

The little gem that is BusyBox (for Windows)

2011-04-07T22:20:00.000-07:00

As a Windows user (no shame) I have, for years searched for a simple GNU-like toolkit - grep, awk, tail and other such goodies enjoyed by Linux users. Yes, there's Cygwin but it's a beast - too big and a pain to install. Sometimes, I've even resorted to starting a Linux VMWare image just to run a simple awk script to munge some log files.

But today...today I found BusyBox and there's a compact 600KB BusyBox exe for Windows! What does it have? Well.. what does it not have?! It has all the essentials:

[, [[, ar, ash, awk, base64, basename, bash, bbconfig, bunzip2, bzcat,
bzip2, cal, cat, catv, cksum, cmp, comm, cp, cpio, cut, date, dc, dd,
diff, dirname, dos2unix, echo, ed, egrep, env, expand, expr, false,
fgrep, find, fold, getopt, grep, gunzip, gzip, hd, head, hexdump, kill,
killall, length, ls, lzcat, lzma, lzop, lzopcat, md5sum, mkdir, mv, od,
pgrep, pidof, printenv, printf, ps, pwd, rm, rmdir, rpm2cpio, sed, seq,
sh, sha1sum, sha256sum, sha512sum, sleep, sort, split, strings, sum,
tac, tail, tar, tee, test, touch, tr, true, uncompress, unexpand, uniq,
unix2dos, unlzma, unlzop, unxz, unzip, usleep, uudecode, uuencode, vi,
wc, wget, which, whoami, xargs, xz, xzcat, yes, zcat

This is where I'd use it the most - to compress and summarize JVM thread dumps for quick analysis. It's based on JPMP, but here's my version of it. First, download BusyBox for Windows and then use the simple script below to munge your JVM thread dump.

This is the first part of the script:
This is the awk pattern that is used by the script above.
All you have to do now is run it against your thread dump file:

jpmp.bat ..\jstack.out > ..\jstack.out.log

And it converts a huge file like this...

2011-04-07 20:44:06
Full thread dump Java HotSpot(TM) 64-Bit Server VM (16.2-b04 mixed mode):

"TimerQueue" daemon prio=6 tid=0x000000004ec33000 nid=0x1268 in Object.wait() [0x000000004a3cf000]
   java.lang.Thread.State: WAITING (on object monitor)
 at java.lang.Object.wait(Native Method)
 - waiting on <0x0000000034004608> (a javax.swing.TimerQueue)
 at javax.swing.TimerQueue.run(TimerQueue.java:232)
 - locked <0x0000000034004608> (a javax.swing.TimerQueue)
 at java.lang.Thread.run(Thread.java:619)

"D3D Screen Updater" daemon prio=8 tid=0x000000004af1e000 nid=0x186c in Object.wait() [0x000000004f40f000]
   java.lang.Thread.State: TIMED_WAITING (on object monitor)
 at java.lang.Object.wait(Native Method)
 - waiting on <0x0000000034e16ba8> (a java.lang.Object)
...
...
...
...
"Reference Handler" daemon prio=10 tid=0x0000000000823800 nid=0x18e4 in Object.wait() [0x000000004940f000]
   java.lang.Thread.State: WAITING (on object monitor)
 at java.lang.Object.wait(Native Method)
 - waiting on <0x0000000034dda018> (a java.lang.ref.Reference$Lock)
 at java.lang.Object.wait(Object.java:485)
 at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:116)
 - locked <0x0000000034dda018> (a java.lang.ref.Reference$Lock)

"VM Thread" prio=10 tid=0x0000000000820000 nid=0x14c4 runnable 

"GC task thread#0 (ParallelGC)" prio=6 tid=0x0000000000777800 nid=0x173c runnable 

"GC task thread#1 (ParallelGC)" prio=6 tid=0x0000000000779800 nid=0x4b8 runnable 

"GC task thread#2 (ParallelGC)" prio=6 tid=0x000000000077b000 nid=0x15d0 runnable 

"GC task thread#3 (ParallelGC)" prio=6 tid=0x000000000077c800 nid=0x199c runnable 

"VM Periodic Task Thread" prio=10 tid=0x0000000049580800 nid=0x1984 waiting on condition 

JNI global references: 1355

Into a tidy summary like this. Very useful if you have thread dumps from 20 servers taken every 30 seconds.
All this without leaving the comfort of your Windows system!

2 j.lang.Object.wait,j.io.PipedInputStream.read,j.io.PipedInputStream.read,sun.nio.cs.StreamDecoder.readBytes,sun.nio.cs.StreamDecoder.implRead,sun.nio.cs.StreamDecoder.read,j.io.InputStreamReader.read,j.io.BufferedReader.fill,j.io.BufferedReader.readLine,j.io.BufferedReader.readLine,sun.tools.jconsole.OutputViewer$PipeListener.run
1 sun.awt.windows.WToolkit.eventLoop,sun.awt.windows.WToolkit.run,j.lang.Thread.run
1 j.lang.Object.wait,sun.java2d.d3d.D3DScreenUpdateManager.run,j.lang.Thread.run
1 j.lang.Object.wait,jx.swing.TimerQueue.run,j.lang.Thread.run
1 j.lang.Object.wait,j.lang.ref.ReferenceQueue.remove,j.lang.ref.ReferenceQueue.remove,sun.java2d.Disposer.run,j.lang.Thread.run
1 j.lang.Object.wait,j.lang.ref.ReferenceQueue.remove,j.lang.ref.ReferenceQueue.remove,j.lang.ref.Finalizer$FinalizerThread.run
1 j.lang.Object.wait,j.lang.Object.wait,sun.awt.AWTAutoShutdown.run,j.lang.Thread.run
1 j.lang.Object.wait,j.lang.Object.wait,j.lang.ref.Reference$ReferenceHandler.run
1 j.lang.Object.wait,j.lang.Object.wait,j.awt.EventQueue.getNextEvent,j.awt.EventDispatchThread.pumpOneEventForFilters,j.awt.EventDispatchThread.pumpEventsForFilter,j.awt.EventDispatchThread.pumpEventsForHierarchy,j.awt.EventDispatchThread.pumpEvents,j.awt.EventDispatchThread.pumpEvents,j.awt.EventDispatchThread.run

Until next time!

Dabawalas and other books I read recently

2011-03-23T20:35:00.000-07:00

Some interesting books I read in the past few months. Needless to say they were mostly, all Sci-Fi:

The Engines of God by Jack McDevitt. Not good at all
Iron Sunrise (Singularity) by Charles Stross. Average read
The Collected Stories of Vernor Vinge by Vernor Vinge. Not too bad. I was expecting something better
A World Out Of Time by Larry Niven. Starts off quite well for somthing that was written 35 years ago. Predictable ending
Dabawalas: Lessons for Building lasting success based on values by Shrinivas Pandit. A very interesting distraction from my regular reading. An inspiring story about Mumbai, India's lunch carriers. An astonishing Six Sigma error rate from a loosely organized band of mostly rural workers!

Until next time!

What's missing in Google Search

2011-03-23T19:46:00.000-07:00

Let's face it, most of the world relies on Google Search to find information on the web. I do. In this day and age of Facebook, Twitter, LinkedIn, social bookmarking sites and other "social applications", Google Search is still years behind.

Some basic features that are sorely missing from their flagship product:

Linking to a search result. Even Google Maps has this feature, but Search does not
Creating a bundle of links like Bitly from some selected search results

Why? Because it makes it easier to share research with colleagues and friends. It also helps to bookmark only interesting links when you are looking for some information and not have to wade through tons of results.

I've suggested this feature to Google a couple of times, but it seems to have fallen on deaf ears. I hope at least the Bing team is listening.

This is what I'd really love. To start with, at least:
(If you were wondering, I used Balsamiq to create the mock-up)

2011-03-21T18:39:00.000-07:00

Entropy is the greatest enemy of life, ideas, memory and hope.

Monterey bay

2011-02-17T17:28:00.001-08:00

Monterey bay, originally uploaded by ashwin.jayaprakash.

Monterey bay sunrise

2011-02-17T17:27:00.001-08:00

Monterey bay sunrise, originally uploaded by ashwin.jayaprakash.

Monterey bay

2011-02-17T17:26:00.001-08:00

Monterey bay, originally uploaded by ashwin.jayaprakash.

Going native, yes to SQL and other stories

2011-02-02T05:47:00.000-08:00

Some interesting performance related articles and links I've come across in the past few weeks:

A useful thread discussing Voldemort's performance compared to Cassandra. Even more interesting to note is that LinkedIn runs 18G heaps for Voldemort+BDB.

HBase guys doing some work around the JVM GC, reminiscent of arenas and slab allocators.

Native code:
Java Fast Sockets - a research project around alternative, high performance socket implementations for Java and its spin-off company. The company site still looks like it's in stealth mode. A downloadable version would've been nice. A "free" version would've been nicer.

If you thought Java Classloading was tricky and JVM startup times are better these days - look at what the Firefox and Chrome guys have been up to - bypassing normal DLL loading and pre-fetching pages from disk:

Another interesting read about how debuggers work internally.

Yes to SQL:
Some libraries and notes for SQL sharding and replication:

Symmetric DS
Tungsten SQL Router
shard-query
8 substitution rules for running SQL in parallel

Some interesting SQL tips and tools:

Reverse engineer snowflake join diagram generator
PostGre explain plan "explainer"

Until next time!

Ray Mears

2011-01-25T21:31:00.000-08:00

If you've never heard of Ray Mears and his multiple BBC series on bushcraft, woodlands survival and generally enjoying time out in the woods, then it's time you watched some of his videos. This is unlike other "TV presenter vs nature" shows you commonly see on TV. Ray Mears shows how you to work "with" nature in his relaxed and pleasant presentation style. I would place Ray Mears in the same class as top BBC naturalists/historians/travelers as Michael Wood, David Attenborough, Michael Palin to name a few.

Enjoy!

Shades Of Gray (Another fix for online reading)

2011-01-21T23:12:00.000-08:00

(Mis)Quoting lines from Billy Joel's song "Shades of grey":

Shades of grey wherever I go
.. .
Black and white is [not] how it should be
But shades of grey are the colors I see

It has occurred to me (after being disappointed with the tiny 6" screen of the Kindle) that we spend a lot of time (those of us who do) on the computer staring at bright and mostly white computer screens. We've become accustomed to the brightness of the white backgrounds. I find it quite stressful to read against a white background for long hours.

After spending a few hours searching (alas) online, I found some tricks that have made my computer time even more pleasant.

1) Fix for PDFs - a poor man's ebook reader:
Change the background of all PDFs you read by changing your preferences in Adobe Acrobat Reader. Go to the toolbar "Edit > Preferences > Accessibility > Document color options". Check the box that says "Replace Document Colors" and choose a gray background as shown in the screenshot.

Note the background color - 192-192-192, the magic combination.

And this is what it will look like. You can view it in full screen mode and almost convince yourself that you are reading an ebook.

2) Fix for IntelliJ:
Something similar can be done for IntelliJ. Import this JAR file with color settings for IntelliJ 10 using "File > Import settings".

Who said "gray areas" are bad? Enjoy!

Making your online reading even more pleasant

2011-01-19T19:58:00.000-08:00

What better way to read a whole bunch of articles that you've been saving for later than to "print" it all and read?

I'm a heavy user of Readable and Readability, but nothing beats printing everything into a PDF, logging off and then reading it comfortably on your ebook reader (if you have one, which I don't. Yet). Well..paper if you really have to.

After a lot of searching I found this wonderful addon for Firefox which lets you print all your webpages, html or text files on disk from the command-line. With this tool you can even write a batch file with all your links and print them into PDFs from the command line (via: MozillaWiki).

Once you've generated all your PDFs, you can even merge them all into a giant PDF using this.

And you are all set!

So many products... so many choices

2011-01-08T22:43:00.000-08:00

Something akin to the Efficient-market hypothesis or the Informationally Efficient Market (the opposite of) that might explain why the market can sustain an ecosystem of products and solutions - even sub-standard ones.

[Update: May 1, 2011] Porter's Five Forces model is a very accurate analysis of this problem.

Hiking in Russian Ridge OSP

2011-01-08T20:19:00.000-08:00

Another year and a nice hike to begin it. I've hiked here a few times before and I still love it.

This time I got to see a coyote waiting over the ridge and looking down at passing hikers and waiting to pounce on a swarm of little birds that were feeding on seeds on the hillside:
(Shot from a camera phone. Bad quality)

Proximity search using SQLite's FTS feature

2010-12-29T20:11:00.000-08:00

A few months ago I was playing with SQLite's Full Text Search feature. I was especially interested in the Match-Near-Term operator - which allows you to search for a bunch of terms that are with 'm' words of each other. Lucene also has this feature (obviously) called SpanQuery. This is called Proximity search if you didn't already know.

This kind of search has its limitations - so does SQLite, especially performance problems for large data sets. I chose SQLite with the SQLite-JDBC driver because of its simplicty of setup and SQL interface (duh!). I created the FTS table in an in-memory database and tried some simple queries. It's not too bad. I'll just file it for later.

Here's the code. I just create 2 streams of stock ticks (all contrived, just like the rest of the code) and try to search for patterns in the 2 series. It does not exactly do what I wanted it to, but it was fun to play with the concept.

Enterprise technology landscape from 10,000 ft above - circa 2010

2010-12-24T19:22:00.000-08:00

[Updated: Dec 25, 2010]

My personal view of where some technologies stand, today:

Happy holidays and a happy new year!

2010-12-22T08:58:00.000-08:00

If you are going to lose your socks, make sure that you lose it in pairs.

What they did not teach in OOP/OOAD class

2010-12-12T19:07:00.000-08:00

For over a decade the Gang Of Four Design Patterns or the GoF patterns are they are fondly referred to have become one of the favorite topics in job interviews. And for good reason. It has even led to the rise in the popularity and acceptance of spin offs like - J2EE Blueprints, Enterprise Integration Patterns and even Anti-patterns.

Would it be too much to ask for to teach these concepts in school today in the final semester before sending graduates off into the real world?

However, knowledge of the GoF patterns is not sufficient to build elegant systems. In fact it must be said that an over-reliance and blind following of the GoF patterns quite often leads to bloated and over-engineered systems. Case in point - Spring superseded a bloated J2EE. Google Guice and JEE CDI are in turn attempts to improve upon Spring which itself has gained a lot of weight over the years.

In my experience, I have come to realize that in order to insure a more complete and proper understanding of the art of design and its application in a complex software system, there are 2 other essential sets of design patterns. The lesser known and under used ones:
    1) GRASP - General Responsibility Assignment Software Patterns
2) SOLID - Single responsibility, Open-closed, Liskov substitution, Interface segregation and Dependency inversion

Where the GoF patterns and their spin offs explain "how" to build the components; SOLID and GRASP help in understanding "why" those components, packages, abstractions, interfaces and dependencies have to be built and assembled in a certain way.

To drive home the point, just sending off graduates with partial knowledge i.e GoF = "How" and without SOLID + GRASP = "Why" would be like teaching automobile engineers how to machine parts of a car and not teaching them how to assemble the parts to make a drivable car.

If students are expected to figure out the "why" on their own at their first jobs, they will unwittingly build and design Rube Goldberg type of software, inflicting the source code with factories of factories, bad adapters that don't do anything, redundant interfaces, singletons that resist unit testing and the list goes on.... until they learn from experience (if at all). For it takes years of experience and guidance to gain a holistic view of complex systems. Systems thinking also helps a great deal.

While we are discussing the subject of good design there is another important aspect that is even less understood - API design. There is a remedy for that too. Joshua Bloch's - How to Design a Good API and Why it Matters.

In conclusion, I'd like to list down some famous quotations and rules of thumb that help me when I'm designing a particularly tricky system:
   - Simple things should be simple, complex things should be possible (Alan Kay)
   - Simplicity before generality, use before reuse (97 Things ..)
   - Ask yourself if a feature or its design is necessary and sufficient. Anything more is a waste. Anything less means the job is not complete

Until next time!

LinkedIn's Kafka messaging project

2010-12-07T23:19:00.000-08:00

Kudos to the LinkedIn team for making another highly focused and elegant project available as open source - Kafka. In spite of its name it is anything but Kafkaesque.

Kafka seems to be a serious attempt to address the messaging problem by starting from first principles. Not having played with the project yet, but from just reading the design doc it looks like a well thought out design.

I have written about the scalability limits of push-systems that are somewhat common to JMS implementations - here about polling from NoSql instead of push, a little here about JMS spec needing an upgrade and vaguely here when talking about alternatives to 2 phase transactions.

The alternative systems like Flume, Scribe, Hedgwig, Chukwa and such are too log-file-collection focused. Whereas Kafka looks more like a regular messaging system with a clean polling mechanism. Explicit polling with good storage automatically solves many of the problems that I had written about here like retries, slow consumers/flow control and durable subscriptions. I'm particularly glad to see that they've read the Varnish article on OS disk caching which Redis seems to have somewhat muddled up (comment #29). Funny, zero-copy was something I was exploring just a few weeks ago with Netty.

I don't however foresee any enterprise projects switching to Kafka immediately. Its performance and cost of license (ASL) might not be enough to motivate people from trying it out. The strangely simplistic yet clever design does require some careful reading of the docs and understanding of the APIs. Hopefully it will gain a wider user base unlike their other nice project Voldemort - another simple and elegant project.

Also be sure to have a look at their new disk store - Krati. I'm even more glad to see that all these projects are in Java (actually Scala).

Until next time!

Clever Enum tricks and some things to read over the weekend

2010-12-04T00:31:00.000-08:00

Here's a Java goody - changing the default maximum compile errors reported by Javac:
   http://forums.sun.com/thread.jspa?messageID=2250634#2250634

Clever things that you can do with Java Enums:
   Create a hierarchy - http://java.dzone.com/articles/enum-tricks-hierarchical-data
   Make it implement an interface - http://api.neo4j.org/current/org/neo4j/graphdb/RelationshipType.html

And some bizarre things to do like - converting Java to native:
    http://nestedvm.ibex.org/
    http://llvm.org/svn/llvm-project/java/trunk/docs/java-frontend.txt
    http://www.vishia.org/Java2C/html/features.html

What would happen if you tried to bypass the Sql engine in MySql? You'd get 750,000 reads per second!
    http://yoshinorimatsunobu.blogspot.com/2010/10/using-mysql-as-nosql-story-for.html

Some Hadoop and cloud related presentations worth reading:
    http://www.cloudera.com/resource/hw10_hbase_in_production_at_facebook
    http://www.cloudera.com/resource/hw10_apache_zookeeper_at_yahoo
    http://www.slideshare.net/adrianco/netflix-on-cloud-combined-slides-for-dev-and-ops

Scalable compute & storage frameworks - A Refcard (in progress)

2010-11-21T12:12:00.000-08:00

If you have been closely following the NoSql space or even shown a mild interest in scalable technologies such as Compute Grids, Data Grids, Distributed Caches or the countless other terms that people use interchangeably - you have probably realized that most Architects do not have the time or the resources to investigate the sift through the noise and decide on what to use.

Since I've had some experience using one such framework and also because I follow the progress of some others, I thought it would be helpful to everyone if I put together some information.

Please share and contribute information. Spread the word. Your efforts will be acknowledged.Ask for permission to work on the Wiki and Spreadsheet.

What I have done is created a Google Code project: scalable-frameworks where I hope I can spare the time to keep it updated and enlist some help from the community at large to gather correct information.

The intention is for it to serve as a ready reckoner and not be complete or authoritative
Performance is a criterion that has consciously been excluded from the lists here to avoid flame wars
For the full information it would be best to visit the actual product's/project's website
It is not official, nor has it been prepared by thorough research
If you have questions or would like to clarify/contribute, please get in touch

To start with, there are 2 parts:

A very simple introduction with images describing the basic concepts
A spreadsheet that is meant to serve as a ready reckoner - to help you choose the right framework/platform

It has some basic features listed
Pay attention to the features that you would find most useful and pick the project that has most/all the ones you are looking for

Basic concepts:
To help understand the basic processing and storage idioms being explored, here are a few images:

"Store and retrieve" (Scatter-Gather) on a cluster of compute + storage nodes:

"Store, notify changes, apply changes" (Scatter-Relay-Compute) on a cluster of compute + storage nodes:

"Store, notify changes, calculate, notify new calculation result" (Scatter-Relay-ComputeAlert) on a cluster of compute + storage nodes:

Refcard:
(Full Spreadsheet)

Until next time!

Variety is the spice of (the Architect's) life

2010-11-17T22:39:00.000-08:00

A mind map of the various aspects of software - from an architect's point of view:

Hiking in Memorial Park (Off CA 84)

2010-11-13T18:43:00.000-08:00

I decided to go hiking in one of the parks off CA-84 (La Honda). It's a longer drive from I-280 and goes closer to the coast. Driving on LA Honda is also quite fun if the weather is good. I had hiked in the same area a few years ago.

I went to Memorial Park, paid the $5 registration fee and went wandering around the empty camp grounds. I could not find a map anywhere (unlike the other parks) so I just went down to the creek from Tan oak camp grounds and walked along the creek, against the flow. After about a 1/4 mile, you reach a bridge which is actually part of Pescadero Creek Road. There are many camp grounds here. I crossed the bridge and wandered around in the Wurr campgrounds. Still no sign of a trail.

So, I came back to the road and then saw the entrance to Pescadero Creek County Park - Hoffman Creek Trailhead. I went in and kept going. There's a map here but Pomponio trail appears to be in both parks. It's confusing.

After about 10-15 minutes, there's a a junction where Old Haul Road (the one you will on) makes a left. I turned left and kept walking. Then you see a sign that says Pomponio Trail. Make a left here, cross the creek. There is no bridge. If it has rained, I don't know if it's safe to cross the 10 ft span of ankle deep water. There are rocks to step on to help cross the creek.

Pomponio trail looks like an out-and-back trail. There is no loop. I went in for a while and then headed back the same way.

Overall, it's a nice place. No crowd. I was worried that I did not see any fellow hikers until I saw just 1 couple on their way back. Camping here would also be a fun - very convenient too considering how close it is to 280.

Until next time!

2010-11-12T08:21:00.000-08:00

If only the world were immune to diseases like it is to logic...

JMS spec - Time for an upgrade?

2010-11-09T00:07:00.000-08:00

The last JMS specification was written 8 years ago! Since then the world has seen multi-core 64 bit systems, Hadoop, compute grids, data grids, AMQP, ZeroMQ, NoSql, Twitter, Facebook ..... and still JMS 1.1 is the backbone of enterprise systems.

There are a few things however, that are missing sorely from the spec and consequently from any implementation in a "standard" way. Each provider no doubt has an answer to some of its limitations but the emphasis is on the lack of a standard way.

8 years ago, running a whole swarm of machines as a single cluster was rare. But in today's world it is not. It is exactly here that the spec is lacking. I have listed some features below that I would find useful.

Message acknowledgment:

Out of order Acks: Acknowledging messages individually and in an order that is different from how they were received. The spec is vague about this. In some systems acknowledging a message will automatically ack all messages that have been received so far in that session! TIBCO EMS has Explicit Client Acknowledgement that is non-standard but is certainly very useful
Negative Acks: In some systems, if a message causes an exception at the receiving end, that message will not be redelivered by the server until the original client session disconnects. It would've been nice if the spec allowed some kind of a Negative Ack to force the server to redeliver the message to the same or a different session
Batch Acks: Since JMS is used in many setups to correlate multiple messages coming from different queues and considering that Ack'ing is expensive at high message rates; JMS should have a facility to accept a batch acknowledgment of many JMSMessageIds. Similar to JDBC batch statements
Disconnected & Federated Acks: In complex systems where messages can flow through multiple tiers of application servers either as the original JMS message or as an enriched DTO/VO, allowing the final tier in the flow to acknowledge the message purely by JMSMessageId would be very useful. Currently, only the client that received the message from the server can acknowledge it. Also the message has to be held in memory for the duration. In SEDA systems this does not work well and forces the developers to jump through unnecessary design hoops

Message selectors:

Smart selectors: JMS Selectors are very static and expensive to apply at high message rates. They were meant to work as a rudimentary form of Content based routing. What is really needed is a way to let the client run custom logic (like RMI) through the queue and pick what it needs. This way clients should be able to use a modified form of QueueBrowser and consume anything it finds interesting
Context aware routing: ActiveMQ has a non-standard feature called Message Group that can be used to perform smart message routing using a custom header. This would be a welcome feature where data aware routing would provide a huge performance improvement by exploiting data locality to deliver related messages to the same application server and thereby avoiding data/cache thrashing

Also, read this for a different take on the future of messaging.

Until next time, cheers!

"Flexible" design (Willis Tower)

2010-10-27T21:00:00.000-07:00

Inside Chicago's Willis/Sears Tower - creaking sounds (mp3) when the tall building sways in the wind. The swaying is by design - to help it cope with the structural stresses it encounters at the top, from strong winds in stormy weather.

A little short of half a kilometer in height and one of the tallest buildings in the world. Now, that is extreme engineering!

Even Star Trek technology has memory fragmentation issues

2010-10-23T00:28:00.000-07:00

Memory fragmentation problems? Well, even Star Trek holograms have similar issues (1) (2). This is why you need a Compacting Garbage Collector :)

select 'Whoa..' || 'Cool!' from mozilla_history_storage

2010-10-21T23:34:00.000-07:00

SQLite is a brilliant embedded SQL engine and it is used by software that you and I use everyday - Firefox, Android and many more. See earlier reference.
What you might not know is how extensively it is used in Firefox. History, bookmarks all use SQLite. The kind of queries that are used would put many Enterprise applications to shame. I was just curious to see what was under the hood and decided to hunt down the History and Bookmarks source code.


 "SELECT v.visit_date, COALESCE( "
   "(SELECT r.visit_type FROM moz_historyvisits_temp r "
     "WHERE v.visit_type IN ") +
       nsPrintfCString("(%d,%d) ", TRANSITION_REDIRECT_PERMANENT,
                                   TRANSITION_REDIRECT_TEMPORARY) +
       NS_LITERAL_CSTRING(" AND r.id = v.from_visit), "
   "(SELECT r.visit_type FROM moz_historyvisits r "
     "WHERE v.visit_type IN ") +
       nsPrintfCString("(%d,%d) ", TRANSITION_REDIRECT_PERMANENT,
                                   TRANSITION_REDIRECT_TEMPORARY) +
       NS_LITERAL_CSTRING(" AND r.id = v.from_visit), "
   "visit_type) "
 "FROM moz_historyvisits_temp v "
 "WHERE v.place_id = :page_id "
 "UNION ALL "
 "SELECT v.visit_date, COALESCE( "
   "(SELECT r.visit_type FROM moz_historyvisits_temp r "
     "WHERE v.visit_type IN ") +
       nsPrintfCString("(%d,%d) ", TRANSITION_REDIRECT_PERMANENT,
                                   TRANSITION_REDIRECT_TEMPORARY) +
       NS_LITERAL_CSTRING(" AND r.id = v.from_visit), "
   "(SELECT r.visit_type FROM moz_historyvisits r "
     "WHERE v.visit_type IN ") +
       nsPrintfCString("(%d,%d) ", TRANSITION_REDIRECT_PERMANENT,
                                   TRANSITION_REDIRECT_TEMPORARY) +
       NS_LITERAL_CSTRING(" AND r.id = v.from_visit), "
   "visit_type) "
 "FROM moz_historyvisits v "
 "WHERE v.place_id = :page_id "
   "AND v.id NOT IN (SELECT id FROM moz_historyvisits_temp) "
 "ORDER BY visit_date DESC LIMIT ") +

Now...see this. Imagine doing this without SQL? I am however, a little disappointed. I was expecting the code to be using some fancy NGram search like what Lucene does, but it doesn't look like it.


 SELECT DISTINCT null, 
        'place:type=%ld&sort=%ld&domain=&domainIsHost=true
          &beginTime='||:begin_time||'&endTime='||:end_time, 
        :localhost, :localhost, null, null, null, null, null, null, null 
 WHERE EXISTS( 
   SELECT h.id 
   FROM moz_places h 
   JOIN moz_historyvisits v ON v.place_id = h.id 
   WHERE h.hidden <> 1 AND h.rev_host = '.' 
     AND h.visit_count > 0 
     AND h.url BETWEEN 'file://' AND 'file:/~' 
     {QUERY_OPTIONS_VISITS} {QUERY_OPTIONS_PLACES} 
     {ADDITIONAL_CONDITIONS} 
   UNION 
   SELECT h.id 
   FROM moz_places_temp h 
   JOIN moz_historyvisits v ON v.place_id = h.id 
   WHERE h.hidden <> 1 AND h.rev_host = '.' 
     AND h.visit_count > 0 
     AND h.url BETWEEN 'file://' AND 'file:/~' 
     {QUERY_OPTIONS_VISITS} {QUERY_OPTIONS_PLACES} 
     {ADDITIONAL_CONDITIONS} 
   UNION 
   SELECT h.id 
   FROM moz_places h 
   JOIN moz_historyvisits_temp v ON v.place_id = h.id 
   WHERE h.hidden <> 1 AND h.rev_host = '.' 
     AND h.visit_count > 0 
     AND h.url BETWEEN 'file://' AND 'file:/~' 
     {QUERY_OPTIONS_VISITS} {QUERY_OPTIONS_PLACES} 
     {ADDITIONAL_CONDITIONS} 
   UNION 
   SELECT h.id 
   FROM moz_places_temp h 
   JOIN moz_historyvisits_temp v ON v.place_id = h.id 
   WHERE h.hidden <> 1 AND h.rev_host = '.' 
     AND h.visit_count > 0 
     AND h.url BETWEEN 'file://' AND 'file:/~' 
     {QUERY_OPTIONS_VISITS}  {QUERY_OPTIONS_PLACES} 
     {ADDITIONAL_CONDITIONS}         
 ) 
 UNION ALL 
 SELECT DISTINCT null, 
        'place:type=%ld&sort=%ld&domain='||host||'&domainIsHost=true
          &beginTime='||:begin_time||'&endTime='||:end_time, 
        host, host, null, null, null, null, null, null, null 
 FROM ( 
   SELECT DISTINCT get_unreversed_host(rev_host) AS host 
   FROM moz_places h 
   JOIN moz_historyvisits v ON v.place_id = h.id 
   WHERE h.rev_host <> '.' 
     AND h.visit_count > 0 
     {QUERY_OPTIONS_VISITS} {QUERY_OPTIONS_PLACES} 
     {ADDITIONAL_CONDITIONS} 
   UNION 
   SELECT DISTINCT get_unreversed_host(rev_host) AS host 
   FROM moz_places_temp h 
   JOIN moz_historyvisits v ON v.place_id = h.id 
   WHERE h.rev_host <> '.' 
     AND h.visit_count > 0 
     {QUERY_OPTIONS_VISITS} {QUERY_OPTIONS_PLACES} 
     {ADDITIONAL_CONDITIONS} 
   UNION 
   SELECT DISTINCT get_unreversed_host(rev_host) AS host 
   FROM moz_places h 
   JOIN moz_historyvisits_temp v ON v.place_id = h.id 
   WHERE h.rev_host <> '.' 
     AND h.visit_count > 0 
     {QUERY_OPTIONS_VISITS} {QUERY_OPTIONS_PLACES} 
     {ADDITIONAL_CONDITIONS} 
   UNION 
   SELECT DISTINCT get_unreversed_host(rev_host) AS host 
   FROM moz_places_temp h 
   JOIN moz_historyvisits_temp v ON v.place_id = h.id         
   WHERE h.rev_host <> '.' 
     AND h.visit_count > 0 
     {QUERY_OPTIONS_VISITS} {QUERY_OPTIONS_PLACES} 
     {ADDITIONAL_CONDITIONS}         
   ORDER BY 1 ASC

There's plenty more where this came from:
- mozilla-central/source/toolkit/components/places/src/nsNavHistory.cpp
- https://developer.mozilla.org/en/Places/Query_System
- https://developer.mozilla.org/en/Storage
- https://developer.mozilla.org/en/Places/History_Service/Design

If you wish to use SQLite from your Java program, there are some drivers available. SQLite also supports a pure memory mode, much like my other favorite database H2.
- http://www.xerial.org/trac/Xerial/wiki/SQLiteJDBC
- http://code.google.com/p/sqlite4java/

Time series, disk swapping, shazam patents and other stories

2010-10-10T20:40:00.000-07:00

Here's a collection of useful Cassandra and HBase articles I've come across in the past few months:

Time series storage in the big 2 NoSQL systems - Cassandra and Hbase:
- http://outerthought.org/lily/417-ot.html
- http://markmail.org/search/?q=cassandra+counter+increment
- https://www.cloudkick.com/blog/2010/mar/02/4_months_with_cassandra/
- http://github.com/zohmg/zohmg

Apache Hive vs Pig:
- http://www.jroller.com/otis/entry/hadoop_land_hive_vs_pig
- http://www.larsgeorge.com/2009/10/hive-vs-pig.html

Cassandra GC and swapping:
- http://blog.mikiobraun.de/2010/08/cassandra-gc-tuning.html
- http://www.riptano.com/blog/whats-new-cassandra-065

Geohashing sounded like an ingenious concept. Here's something built on Cassandra:

- http://www.slideshare.net/mmalone/scaling-gis-data-in-nonrelational-data-stores

Well, yeah that's a lot of NoSQL articles to read. Here's a hilarious video against NoSQL to balance it. (Warning: Watch for foul language. For a more civilized roast, see this)
- http://www.royans.net/arch/mongodb-is-webscale-humor/

Patent trouble . Here's the story of a smart guy who wrote a music recognizer over a weekend and got into some trouble with Patent lawyers.

After a long time, I found a nice JUnit presentation that made me reconsider my decision to switch to TestNG from JUnit.

Some Linux fun - swapping OS pages and opening 500K sockets (Also see above for what Cassandara did to prevent swapping):
- http://blog.urbanairship.com/blog/2010/09/29/linux-kernel-tuning-for-c500k/
- http://jcole.us/blog/archives/2010/09/28/mysql-swap-insanity-and-the-numa-architecture/

Until next time!

Red Munia or Red Avadavat

2010-10-06T10:40:00.003-07:00

Red Munia or Red Avadavat, originally uploaded by SRJP.

Pic taken by my dad - Dr. Jayaprakash.

Red Munia or Red Avadavat

2010-10-06T10:40:00.001-07:00

Red Munia or Red Avadavat, originally uploaded by SRJP.

Pic taken by my dad - Dr. Jayaprakash.

Txn.commit() - Are you sure?

2010-09-26T11:34:00.000-07:00

[+ indicates updated on Sep 27, 2010]

Transactions - do we need them and are people really using them like they are claim to?

We know that transactions are theoretically the best way to keep data consistent, but it might not always be the most practical way to do it.

[+]
There could be a variety of reasons:
- Reduced performance after using transactions
- Lack of proper XA support across all the participating resources
    - "Last resource commit"/XA emulation can leave some edge cases in a mess
    - There could be more than 1 resource that does not support XA. In such cases emulation will not work
- There could be a need for nested transactions which are not widely supported
- The transaction manager might not have proper support for repair/recovery of heuristic hazards
- Multi-step transactions that need savepoints and lack of proper support or semantics for restoring it
    - Transactions that might be too expensive to retry from the beginning
    - If the client program crashes, then having a new client continue the transaction might not be feasible
- Multi-page, lengthy UI forms that need disconnected data sets
- Impractical for long running transactions and so on..

Many others have written about it. I'd rather refer to their notes instead of write my own, from scratch:
- Starbucks Does Not Use Two-Phase Commit
- ACID Transactions Are Overrated
- Computer says no
- Transactions - Overused Or Just Misunderstood (Mark Little)

Remember - if Transactions work for you and all your systems support it, then go for it.

Having said that, there still are many systems where data flows across large applications; where a simpler, resilient and more predictable compensating mechanism is suitable. Simpler it may be, but designing such systems require a lot of foresight and expertise:
- Optimistic concurrency based on version numbers
- Atomic compare-and-swap upsert/update operations
- Polite spin locks and backoff-retry mechanisms
- Clear error reporting
- State capture, repair and consistency checking
- Operation logging, undo and re-apply
- Proper documentation and involvement of Developer/Architect

For much larger systems like Amazon, LinkedIn and the like, availability is as important as consistency. See earlier references - #1, #2, #3 and #4.

Some interesting notes on Transactions that I keep referring to every now and then:
- XA Exposed, Part III: The Implementor's Notebook
- Distributed Transactions and Two-Phase Commit

Hiking in Upper Stevens Creek County Park

2010-09-25T21:26:00.000-07:00

Upper Stevens Creek County Park is just opposite Long Ridge Open Space Preserve on CA 35. You have to go down Grizzly Flat trail and then back up. There are 2 trail heads next to each other - The North and the South legs. You can go down one and come back up the other.

The trail goes about 1.1 miles down where the North and South legs meet. You can go further down to Grizzly flats junction where it meets Canyon trail. There is a nice stream at the bottom. You can cross it and go further down towards Page Mill. I however, turned around and came back up.

This is not an easy trail. It is about as steep as Windy Hill Open Space Preserve, probably a little less. But the whole trail is always in the shade and is very quiet and pleasant.

Whither ORM?

2010-09-18T20:29:00.000-07:00

If you are scratching your head wondering why even after so many years there is still a confusing mix of ORM solutions, then you are not alone.

JPA/JDO/Hibernate/Spring/Mybatis/Cayenne - which one and why?

And if you are planning to write something on your own when there already are so many, then you should probably go read about NIH.

I'm actually amazed that even after the relative acceptance of NoSQL we are still struggling to standardize on ORM for SQL/RDBMS.

It's ~~almost~~ like a religious debate:
- https://www.jfire.org/modules/phpwiki/index.php/Why%20not%20JPA
- http://www.datanucleus.org/products/accessplatform/persistence_api.html
- http://www.datanucleus.org/products/accessplatform/jdo_jpa_faq.html
- http://www.dzone.com/links/search.html?query=jdo
- http://www.dzone.com/links/search.html?query=jpa
- http://java.dzone.com/articles/jpa-performance-optimization

Good old Apache itself has 2 solid implementations of JPA and JDO. Both seem very mature and very well documented:
- http://db.apache.org/jdo/why_jdo.html
- http://openjpa.apache.org/

Apache also has some offbeat/non-standard implementations. Some dead, some doing well:
- http://cayenne.apache.org/why-cayenne.html
- http://db.apache.org/
- http://www.mybatis.org/ - formerly Apache iBatis

2010-09-18T19:39:00.000-07:00

Reading a busy Twitter stream with @s and #s is as hard as parsing unformatted XML with your eyes - correction, with 1 eye closed.

Books I read in the last few months

2010-09-18T15:26:00.000-07:00

Blindsight by Peter Watts: I thoroughly enjoyed reading this book. Although the ending was a bit of a let down, the amount of research that has gone into writing this book is impressive. It has a very refreshing combination of bio-chemistry, human vision, psychology and AI.

Galactic North by Alastair Reynolds: A collection of short stories. Generally, I try to stay away from short stories because I feel the characters do not have time to develop and neither does the story. This one however has a continuous feel across stories and is worth reading if you liked Revelation Space.

Eifelheim by Michael Flynn: Another Hugo nominee (I think). Not too bad it you'd rather have the story wander off into a medieval village setting during the time of the Black Death. Certainly not in the same league as the Sci-Fi masters.

Liar's Poker by Michael Lewis: This is not sci-fi at all. It's a 20 year old book about an Investment bank - the infamous Salomon brothers. They say history repeats itself. Just replace Salomon Brothers with Lehman Brothers and add a generous measure of greed and short sightedness. This is a very funny book considering what the book is all about. Well worth the read.

Spin by Robert Charles Wilson: Here's one I tried reading but just couldn't get myself to finish it. For a Hugo award nominee this was a disastrous read.

Hiking in Skyline Ridge Open Space Preserve

2010-09-12T14:21:00.000-07:00

Skyline Ridge Open Space Preserve, is right next door to Russian Ridge off CA 35. This is perhaps one of the nicest hikes for beginners. Gentle slopes, good combination of shade and open trails, great view just a mile into the hike, a park bench and a pond (actually 2) at the end of the 1.5 mile Ipiwa trail.

Start from the Skyline parking lot and follow the Ipiwa trail, cross Old Page Mill road and you will reach Alpine Pond. There are many shorter walkways you can use to spend time around the pond. Then head back the same way to Skyline parking.

2010-08-15T19:43:00.000-07:00

If life is a journey, shouldn't we be traveling light?

The blurring line between Messaging and Storage

2010-08-13T00:48:00.000-07:00

Alternate Google Docs link: The Blurring Line (http://goo.gl/HKX2t)

Hiking in Windy Hill Open Space Preserve

2010-08-01T19:13:00.000-07:00

This time unlike the last, I started from the CA 35 entrance, and hiked down first and then back up. 1.8 miles of pretty steep incline each way. Best avoided if you haven't hiked in a while. The view of the entire Bay Area is unbeatable and worth the climb.

Carbonado, Graphs, FUSE, Merge-Join and assorted stuff

2010-07-31T23:17:00.000-07:00

This month in tech... before that, here's a testimonial for an open source project that you can't beat:

You could've been rich - My mother

Moving on, I heard about a persistence API called Carbonado on the Voldemort forums. It's an open source project from the Amazon guys. It's a no frills (read clean and simple) layer that works with Berkley DB and JDBC. It's even blessed by the BDB guys as a nicer layer on top of BDB.

Here's a decent presentation on graph algorithms from the Hadoop summit. Not very detailed, more like best practices and hints. And here's a nice illustration of PageRank using Javascript.

An interesting thread going on between the Hotspot GC team and a HBase engineer facing some GC problems. Have a look at the new generation sizes they've used for some deployments, it was new to me.

If you want to OD on JVM options, there's a list for that too.

Some folks playing with the userland filesystem in Unix - FUSE. Voldemort, Github and all sorts of funny stuff as Filesystems. Reminds me of GDrive.

NoSQL systems are notorious for not being able to do simple Joins. Their answer is Map-Reduce. For running multi-attribute filtering, there's Merge-Join. Google's App Engine which is like a poor man's data store suggests the same (slide 30). I am skeptical of such queries that run on a cluster of machines, without any indexes, burning CPU on all machines, moving data back and forth. Can't imagine what it does to latency.

2010-07-27T21:29:00.001-07:00

Overheard in a coffee shop: "A few yrs ago I was young and restless. Now I'm just old and breathless most of the time".

Apache Cassandra for first timers

2010-07-25T14:27:00.000-07:00

I wanted to get a feel for how Apache Cassandra works, so I downloaded and installed (just copied) the files. I decided to run the single node test. Here's what I did on my Windows 7 laptop:

1) Download and unzip the latest Cassandra zip file to some folder - D:\Dump\apache-cassandra-0.6.3
2) Open a command prompt at the main Cassandra directory and type - bin\cassandra.bat
3) That's it! You have a single node server that is running with the defaults. It creates and starts logging to some default location. In my case it was - D:\var\lib\cassandra\

Now, I wasn't too happy with the default Keyspace configuration - this is the "schema". So, I shut down the server, deleted the log directory and modified the configuration file in conf\storage-conf.xml. I simplified the Keyspace to 2 simple sub-sets - a column family called Message and a super column family called Car.

The more I look at the Cassandra column family structure, the more it reminds me of XML.

Then I started the CLI batch file to punch in some commands. I wasn't expecting this. I was really looking forward to a simple Java client program and there isn't any. So, those HBase guys were not kidding they said Cassandra does not have a simple client program. You have to use a Thrift client or some other third party client like Hector. I wasn't too eager to do that so I just went the command line way.

It seemed easy enough. It takes a few minutes to understand which one is the key name, the column family name and the super column family name. The advantage is that it's like a hierarchy of SortedMaps. Which means that the keys across records do not even have to have the same column names. Notice that there are some slight differences in the columns I've entered like - "Upgrade", "Leather seats" or "AWD" which are not there in the other records. So, there is some flexibility.

Some thought must be given to how efficient the storage is when you intend to store millions of records at the column/super column family/column family level. Search for discussions in the Cassandra-User mailing list. There are lots of such discussions and on which mode is better.

Thoughts:
1) The installation is easy but the lack of a proper client is bothersome
2) CLI looks good for key-value type of queries, but I was really interested in those queries on slices and ranges. I couldn't find anything ready made
3) Hbase and Hive along with Cloudera's Beeswax UI for running SQL-like queries are very compelling. But, have a look at the HBase installation. It doesn't look easy. That's why I decided to try Cassandra.
4) This article here, is the most succinct comparison of Cassandra and HBase

Until next time!

/dev/null on Windows

2010-07-20T22:43:00.000-07:00

I was trying to run Apache ZooKeeper on Windows the other day. Getting it to run was super easy. I was more interested in running it without any file/snapshot logging.

I did ask around in the forums and I thought letting the "dataDir" directory to point to "/dev/null" would solve the problem. But being a (ahem) Windows user I couldn't quite get the "/dev/null" to work. In Windows the equivalent is "nul" but it doesn't quite work when you try to use it from Java. Some operations work, but some don't.

[Update 1:
Strangely getAbsolutePath() prepends the current directory's path but the file does not get created.
Creating nul:\abc.log throws an exception. But nul:abc.log does not and Java says its absolute path is d:\dump\nul:abc.log but the file is not there. Which means that it is indeed writing to the "null" device. I wonder what I'm missing.]

As usual, the full code is here: http://gist.github.com/484116

Here's the output and it shows what works and what doesn't:

Years before Inception (movie)

2010-07-18T10:41:00.000-07:00

Here's a short list of TV episodes where similar concepts of dream manipulation and recursive realities were explored decades ago:

The Avengers 1967:
Deaths Door (A series of Diplomats are drugged and forced to participate in their own nightmares. On waking up, events unfold just like the nightmare - all the way up to the Diplomatic event)

Star Trek: The Next Generation: Season 6:
Ship in a Bottle (A sentient hologram of Dr. Moriarty tricks the crew into thinking they are back on the ship after visiting the Holodeck. In actuality they are in a hologram ship inside another hologram.)

Frame of Mind (An officer is trapped and taken prisoner while on a mission. He is then drugged and his dreams are tampered with. He starts thinking that his actual life on the Enterprise was a delusion and is convinced to find closure with his delusional characters by killing them in his mind among other things)

Star Trek: Voyager: Season 2
Projections (The ships holographic doctor is convinced into believing that he is not a hologram but the actual hologram designer who has got lost in his own mental simulations on a Star base near Jupiter. He is asked to give up control of the ship to end the simulation)

Similar types of episodes in Mission Impossible Season 1 (1966) and 2.

[Update 1: Also see DreamWithinADream]

2010-07-17T11:24:00.001-07:00

Having 2 chins is better than 1... Not!

2010-07-12T23:16:00.000-07:00

It occurs to me that our mind is like a snow globe and the snow is our thoughts and ideas. It is most beautiful when the snow is swirling around the glass.

A simple (Project) Voldemort test on Windows

2010-07-11T23:00:00.000-07:00

Here's a simple Voldemort test program. It's basically the one that ships with the project but with a few, little modifications to make it work on Windows/Cygwin.

First off, the server scripts are all Unix shell scripts. So, I had to install Cygwin on my Windows 7 laptop. Then the most essential bin/voldemort-server.sh script had to be modified a little to work with Cygwin because Java does not recognize the Cygwin mapped Path and Classpaths like /cygdrive/d/Dump/voldemort-0.81. You have to wrap paths with cygpath to map them back to the actual paths: java -cp $(cygpath -w -p -l -a $CLASSPATH) ...

The simple Java client test program needs dist/voldemort-0.81.jar and dist/voldemort-test-0.81.jar. I had to find out about the second jar from their issues list.

That's it! Now, you can start the single node server and run the client Java program as many times as you like.

All the files are available here: http://gist.github.com/472163. Here are the snippets.

Client:

Server script:

Client output:

Bay Area at Sunrise

2010-07-05T09:48:00.000-07:00

Waking up at 4.30 in the morning on a holiday to watch the sunrise is not something people even think of doing. Today, I did exactly that.

I was up before dawn and was on my way to Page Mill Road (off CA 280) to watch the Sun rise. This being my first time (waking up this early, I mean) I was unsure of where to go. So, I chose my regular hiking spots. I drove up Page Mill before Sun rise (5.50 AM) and was well on my way up the hills.

There was no one in sight. No bikers! Yay! I saw quite a few deer grazing next to the road and many hare/rabbits. It was peaceful, cool and smelled like wild flowers. I drove down Page mill, stopping at a few places to take pictures. At this hour, all the parks are still closed. Your best bet is to drive towards the end of Page Mill, beyond Montebello and even cross the CA 35 intersection. There is one area which leads to private property. You can pull over in front of the gate and take a few snaps quickly. It's a pity there aren't any vista points to park and enjoy the sun rise on Page Mill.

(Move your mouse over the images to see descriptions.)

Then, when I reached CA 35, I continued down Page Mill for a few miles and then turned around. Went north again on CA 35. Just a mile or so from that intersection, there is a vista point overlooking the Bay Area. This is a nice spot. The sun had already risen by the time I got here.

Overall, it was worth it. I was back home by 8 AM! The Bay Area was still cloudy. It was a surprising discovery for me to see that the hills are actually clear of fog and clouds. It's only at sea level, where the early morning are gray and dull.

Weekend at the Zoo(Keeper)

2010-07-04T19:28:00.000-07:00

I've written about Apache ZooKeeper before, but I had never actually tried it. Only today did I get a chance to play with it.

The ZooKeeper recipes really piqued my curiosity. So after spending a few hours reading the docs, I decided to give it a try. My interest was purely the performance side of it. ZK makes it very clear in the docs that it excels under read-heavy workloads. And the more replicated servers you add, the better it gets. They were not kidding.

I have my test code here -http://gist.github.com/463930. Keep in mind that this is a simple test, perhaps even a micro benchmark. It does not even have the minimum 3 servers for a quorum. Remember, my tests were run on a new (2010) laptop with 4 hyper threads with some simple Xms/Xmx JVM settings and everything else remaining as is - default, out of the box. This is by no means a representative test. There are official numbers on the ZK wiki with tests run on a real server class machine. You should have a look at those too

Well, what can I say - it is a little slow. Even writing messages with a few bytes take a while. Granted, each write in a loop requires a network call. So, if I write a 1000 messages, it requires a 1000 remote/network calls. The CreateMode.PERSISTENT_SEQUENTIAL is very handy, like the RDBMS autogenerated-id column.

I would've liked a few more batch-oriented calls like getDataForChildren() and createIfAbsent() instead of making 2 calls first to find out the child names and then to get the actual data. But hey, I'm just trying to shoehorn it into a wrong usecase.

This is the simple test and the sample console output is further below. You can always get the full code from my Gist repo :

Console output:

Hiking in Russian Ridge (again)

2010-06-27T10:28:00.000-07:00

I went hiking in Russian Ridge (again) yesterday. I had been there just a few weeks ago. This time, I took 2 photos from my cell phone. So, they're not so great. Summer is here and it was hotter and so everything has started to dry up. Too many flies on the trails for some reason. The open trails here mean that you should best avoid it during summer.

Yes, that's a blanket of fog on the trees, in the background. They are not clouds. It looks wonderful.

Funny JavaZone Video

2010-06-26T09:57:00.000-07:00

Here's a funny vid to watch over the weekend (it's only a few minutes long). Still strictly Java related, mind you:

Varnish, Voldemort, Virtualization and other vaguely related stuff

2010-06-24T22:21:00.000-07:00

A few interesting articles I read these past 2 weeks:

1) Voldemort presentation at QCon - Project Voldemort at Gilt Groupe. I didn't know that Voldemort was storage independent. Interesting to see the different storage options they tested. Lots of other useful presentations from QCon London 2010.

2) Some fairly detailed and low level notes on systems stuff like swapping and paging from the guys who wrote Varnish page cache - You're Doing It Wrong. The original Varnish Architect notes describes the remaining details.

3) The latency and throughput numbers of Market data - http://www.latencystats.com/ and http://www.marketdatapeaks.com/

4) Azul Systems opens up a part of their awesome runtime - http://www.managedruntime.org/. They have a Linux kernel module for better memory management. I'll follow this with interest, being a fan of the awesome Dr. Cliff Click.

5) Some questions I had posted on Virtualization expert blogs about when not to use them. There's no doubt that Sys Admins and IT guys want everything in the data centers to move to a 100% virtualized environment. Apparently it not just about server consolidation anymore. Companies are willing to sacrifice some performance for easier provisioning. To me the performance reduction is disappointing. It's like 2001 all over again when Java was slow and there was a lot of resistance to using it in production. Eventually the JVMs became faster (well, so did the processors to some extent) and people stopped thinking twice about using Java. Now, just when you thought Java was going to run blazing fast on multi-core, there's a second VM under the Java VM to slow things down. Dang! So much for progress. Now we have to wait for 10G pipes , SSDs and mega-multi-core to make up for the drop in power.

6) ORM - do we still have that impedance mismatch? Why are there so many standards - JDO and JPA and so many frameworks? Apache itself has so many. Then there is Hibernate, DataNucleus and EclipseLink.

7) Does Queuing interest you? ZeroMQ looks interesting. Anything that is open source interests me. Here's some eval notes on open source queuing systems. A little dated but still interesting.

Until next time!

This quarter in Sci-fi

2010-06-15T22:38:00.000-07:00

1) Protector by Larry Niven has a very relaxing and smooth flow. Simple, unadulterated and enjoyable 80's Sci-fi.

2) The Scar by China Mieville. Another Mieville classic. This story is set on a pirate ship, complete with science-fantasy, steampunk and magic. Loads of sugary goodness, like his other novels.

3) The Light of Other Days by Arthur C. Clarke and Stephen Baxter. What happens when 2 masters work together? You get a Hard Sci-Fi masterpiece. If every action you make were to be visible later in the future with the help of wormhole cameras, would we still lie, commit crimes and injustices? A thought provoking novel. We talk about Facebook, Google and privacy. Hah! You should read this book. The issues in the novel are way more complex. Society and species level.

4) Ilium by Dan Simmons. A fat book, you have been warned. A strange mix of sci-fi, Greek gods, Trojan war, Shakespeare and post humanism. Too bad this is just part 1. I would say, it's almost as good as Hyperion.

Hadoop, CDI, Weld, HSQL and Chuck Norris Java jokes

2010-06-13T22:40:00.000-07:00

Big data doesn't get bigger than this...very rarely. i.e if you exclude GOOG, EBAY and MSFT. Facebook now has the largest Hadoop installation, surpassing Yahoo. Hive is the main interface into Hadoop for the Facebook analytics team, it seems.What caught my attention was the 16G heap for the JobTracker nodes and 58G heap for the NameNode.

I still find it hard to believe that the established OLAP and DW companies cannot offer competitive prices and solutions. One of them has docs explaining how they do joins in clusters - SQL Request and Transaction Processing. Just the doc for Join processing runs up to 400 pages. Impressive to say the least!

HSQL has a new re-written core with MVCC and 2 phase locking. This version 2.0 is now about as good as H2. I like the competition.

I've been trying to understand where this new (CDI) Dependency Injection business was heading. After digging up a few articles, I found these interesting: 2 JSRs - 330 and 299. 299 extends 330 as described here. And obviously, Spring, naturally is not very enthusiastic about making JEE easy to use - read the comments in that 299-330 article. JBoss' Weld is the RI.

And here's a bit of fun, courtesy Chuck Norris:
1) Chuck Norris Java jokes - http://www.ovisual.com/4/
2) Chuck Norris facts - http://www.chucknorrisfacts.com/chuck-norris-top-50-facts

Until next time!

Data cleansing, perceptual hash and others

2010-05-26T20:45:00.000-07:00

Got dirty data? I am very impressed with this data cleansing tool built by the Freebase guys. Specifically because it is open source and the UI is so well done - Freebase Gridworks.

Haha, yes another NoSQL system which claims incredible performance - KumoFS.

Spring. No, not the season, I mean the framework. I have many questions about why it's required in light of the supposedly simplified new JEE spec.

I wonder how all those various distributed Lucene index implementations perform. Apache Solr itself offers most of those enterprise features.

Perceptual hashing to detect duplicate images. I'll file this under all the other "interesting" hashing techniques.

The LinkedIn guys have a simple implementation of a load balancer using Zookeeper and NIO/Netty. Nothing new here, but this one is in Scala. Apparently they like Scala too, just like the Twitter dev team.

Have a nice and long (for some) weekend!

The 3 laws of error handling (and everything in life)

2010-05-15T17:03:00.000-07:00

Having spent a few years wading through production log files and unruly code, I've come to some startlingly unoriginal conclusions. Also being a Science Fiction fan, I've come up with these 3 laws (Heard of the Three Laws of Robotics?):

The 3 laws of error handling (and everything in life):

1) CYA

2) Take responsibility

3) When in doubt, refer #2

Now, there are some of you who are probably thinking "Take responsibility" should've been #1, but that would just sound very cliched. Let's be honest, CYA is what everyone does first in the real world. But #2 and #3 help keep that CYA attitude in check. It makes the world a better place. Well..sort of.

So, how exactly does this apply to umm.. programming? Let's take an arbitrary simple example that I found on the internet:


java.lang.IllegalArgumentException
at org.apache.axis.encoding.ser.BeanPropertyTarget.set(BeanPropertyTarget.java:157) 
at org.apache.axis.encoding.DeserializerImpl.valueComplete(DeserializerImpl.java:249) 
at org.apache.axis.encoding.ser.ArrayDeserializer.valueComplete(ArrayDeserializer.java:583) 
at org.apache.axis.encoding.DeserializerImpl.endElement(DeserializerImpl.java:509) 
at org.apache.axis.encoding.DeserializationContext.endElement(DeserializationContext.java:1087)
at org.apache.axis.message.SAX2EventRecorder.replay(SAX2EventRecorder.java:171)
at org.apache.axis.message.MessageElement.publishToHandler(MessageElement.java:1141)
at org.apache.axis.message.RPCElement.deserialize(RPCElement.java:236)
.. .. ..

This stack trace is not very helpful is it? If your program threw something like this in production what would you have done?

1) How can you defend (if it comes to that) that it was not something in your code?

2) Perhaps the input/arguments were wrong or the library you called caused it

3) So, does this leave your object in a corrupt and incomplete state?

4) Should the caller retry and hope that the problem does not occur again?

5) What is the alternative? What now? How do you get around it? Can you get around it?

See? There are so many questions and if this happened in production, then you would have 0 answers.

How does the "3 laws" help? If you structure your code like this:

CYA:

- The error was caused because...

- The input that was expected was... but was actually...

- We

- Tried these things but...

- Retried so many times but...

Take responsibility:

- The error is

- Recoverable - how?

- Un-recoverable because... Therefore you have to...

- The system/instance is now

- Still ok except for...

- Unstable and so you have to... or we already are doing...

Here's one simple way to implement parts of it:


java.lang.Exception
   + getMessage()
   + getCause()

        Δ
        |
        |
        
com.javaforu.util.NiceException
   + isCallersFault()
   + isOperationRecoverable()
   + isCalleeCorruptOrUnstable()

Cheers!

Orient database, Zookeeper, Interest rates, Yield curves and more NoSQL

2010-05-13T21:23:00.000-07:00

By now you would've thought that people had stopped developing old fashioned datastores...well think again. I chanced upon another database - Orient. It supports many modes (or claims to) - raw storage, SQL, Object oriented along with ACID transactions.. sounds very interesting. And it's under the Apache License.

We've been reading so much about Hadoop and Cassandra and NoSQL everywhere, but not much about another essential Hadoop sub-project. It's worth using in its own right - ZooKeeper. Check out their recipes page.

Some more ZooKeeper coverage on other blogs:

1) http://www.igvita.com/2010/04/30/distributed-coordination-with-zookeeper

2) http://coffeesgone.wordpress.com/2010/05/05/zookeeper-locking/
3) http://ria101.wordpress.com/2010/05/12/locking-and-transactions-over-cassandra-using-cages/

Voldemort vs Cassandra...Wait.wait...this is not a rehash of that Twitter-Cassandra article that's making its rounds on the interwebs. This is a performance comparison - http://blog.medallia.com/2010/05/choosing_a_keyvalue_storage_sy.html

Had enough of reading about software? How about investments and interest rates and Fed policies? It's a nice distraction:

1) Interest rates and bond investments

2) U.S. Monetary Policy: An Introduction

3) Using the yield spread to forecast recessions and recoveries

Until next time.

2010-05-05T08:39:00.001-07:00

Rule of thumb for Powerpoint slides - If you cannot read the text on your Blackberry, then you have too much content. It's a simple, low-def test much like the 5 second test to see how much people will/can remember.

2010-05-02T18:09:00.000-07:00

I tried to cash a Reality Check and it bounced.

Hiking in Russian Ridge Open Space Preserve

2010-04-24T22:41:00.000-07:00

Russian Ridge is an easy to find hiking area. It gets pretty crowded before noon. Spring is undoubtedly the best time to visit. Most of the trails are out in the open and there is no shade. So, it is probably best to avoid in Summer. But in Spring with all the hillsides covered with spring flowers, it is certainly worth a visit.

2010-04-20T19:28:00.000-07:00

Overheard at someone's cafeteria - "There must be some kinda way out of here said the ~~joker~~ broker to the ~~thief~~ chief......all along the watch tower.." [Jimi Hendrix]

Hiking in Long Ridge Open Space Preserve

2010-04-17T17:04:00.000-07:00

I went hiking with friends to Long Ridge Open Space Preserve. We did the 4.71 mile loop on Peter's Creek Trail and the Long Ridge Trail. It's a mild trail, very pleasant surroundings. The best part is the meadow overlooking the Pacific at a distance. This is midway along the hike.

Also, don't forget to enjoy the small lake (pond?) in the first quarter of the loop. It seemed to be covered with algae. It didn't smell though.

Golden ratios, collapse of complex business models, time debt and GM (GM?)

2010-04-12T20:53:00.000-07:00

JEXL version 2, the Apache Expression Language is out. It may be slower than MVEL (very likely) or Spring EL (don't know for sure) but JEXL is from Apache and that deserves a special mention. The v2 API looks good with facilities to plug in/customize many aspects of parsing and evaluation.

Need to sort gigabytes of text but don't have Hadoop or Unix "sort" handy? Not to worry. External sorting is a remarkably simple concept that does chunk-wise sorting and merging. Isn't that MapReduce without the pain of a Hadoop cluster setup?

Clay Shirky's note on the collapse of complex business models - after reading this I couldn't help thinking about the Innovator's dilemma and how some big companies need some kind of rebooting at some point (negative marginal value). And how open source is a disruptive model employed by many small companies to compete with larger software companies. For a long time their documentation and feature set is poor compared to more established companies but eventually they catch up. But during "awkward teenager" period, some customers are willing to use it, which is perplexing. Good enough is perfectly ok for some purposes I suppose.

Much like GM and its endless problems which eventually led to the closure of their Fremont plant (among other things). This in spite of a collaboration with their arch nemesis Toyota! Speaking of quality, this is a painful reminder of how bad quality has to be addressed ASAP. Not fixing quality in time (before release) is in effect giving yourself a time debt. Time debt? This guy defines it as - "Basically, time debt is anything that you do which will commit you to doing unavoidable work in the future." If you don't fix the problem before it leaves the assembly line like that Fremont plant, after the release you/Engineering, Support, Product management will spend hours identifying and fixing something that could've been fixed for much less cost before the release, with interest. Duh! Think of your customer's loss of faith too.

Oh, I almost forgot, here are some UI tips that require Math. I especially liked the Golden ratio. Very elegant.

Until next time..

2010-04-12T19:09:00.001-07:00

Life is a long winding road....better drive a car that handles well.

2010-04-08T19:17:00.000-07:00

Old Chinese proverb: If your IQ is below room temperature, then move to a warmer climate.

2010-04-05T19:06:00.001-07:00

Ice cream should come in only 1 flavor - "Self control" with a topping of nuts.

2010-04-03T10:09:00.001-07:00

After the Kindle and the iPad, I suppose there won't be any "Death by a 1000 paper cuts"? Does this mean that our lives are safer now?

Blue tailed bee eaters

2010-03-31T19:57:00.001-07:00

Blue tailed bee eaters, originally uploaded by SRJP.

Pic taken by my dad - Dr. Jayaprakash.

Blue tailed bee eaters

2010-03-31T19:56:00.001-07:00

Blue tailed bee eaters, originally uploaded by SRJP.

Pic taken by my dad - Dr. Jayaprakash.

Make your online reading more pleasant

2010-03-29T22:32:00.000-07:00

If you spend a lot of time reading online, like me then eye strain is probably your biggest complaint. You can stop worrying, because there's a beautiful tool called Readable.

No, don't worry it's free and does not need any installation. All you have to do is drag a link and drop it on to your Browser's Bookmarks Toolbar.

It turns this .....

into this...! It's the same web page, just the style has changed. Beautiful isn't it? You can revert back to the original by just clicking the page.

You can use the theme I use - just drag and drop this link into your Bookmarks and when you are on any web page just click this Readable bookmark. Or you can make one yourself. Here's the actual site with a tutorial - Readable theme setup.

Happy reading!

(Smaller) Compute Grids face off, some Math and Cassandra at it again

2010-03-23T20:35:00.000-07:00

Head over to Dzone to see how these Open Source Compute Grids stack up against each other - GridGain vs Hazelcast (and Hadoop for reference). Compared to Cassandra, Hadoop and Voldemort that's installed on monstrous scales, these are for mere mortals - I mean Enterprise deployments. I say this without any intention of sounding sarcastic.

Oh, talking about Cassandra, did you hear Reddit also switched last week? Cassandra seems unstoppable. I remember just a year ago when Memcached was all the rage. Now it's Cassandra. Big Database vendors (and Storage companies) are definitely taking notice. Last year there was a rash of announcements by DB vendors that they had implemented Columnar storage and MapReduce. It reminds me of Gandhi's quote - "First they ignore you, then they laugh at you, then they fight you, then you win". Way to go Apache projects!

Note to self - The mathematics behind Hadoop-based systems might come in handy later.

Spring Batch - and you thought you needed Hadoop for scalable Batch processing. Hey, didn't I say - mere mortals and Enterprise? I'm not sure how many people are really using this or how good it is. But I wish we had a simple framework like this when I wrote batch programs for a bank a few years ago.

Ever the heard the term Intrapreneur? Big Companies Can Innovate, if they Act Small is worth a quick look.

Peace!

2010-03-23T19:05:00.001-07:00

Spring. I thought of getting the old cycle out. Tires need replacing. All 3 of them.

Semi-educated tax tidbit: TurboTax and Stocks

2010-03-21T23:38:00.000-07:00

Tax season is here again and if you were like me, scouring the internet trying to understand how to fill up that TurboTax form for ESOP and Restricted Stock, then this might be helpful.

(Disclaimer: The information here and even in the links are not Tax advice nor is it any other kind of advice. Don't take my or their word for it. If you see something wrong here, then let me know I'll do my best to correct it. No guarantees whatsoever)

This applies only to Same day sales.

Employee Stock Options:

Net Proceeds = Sale price * num of shares
Date of sale = Sale date

Cost basis = Exercise price * num of shares
Date acquired = Exercise date

Your W2 should already mention the ordinary income earned = Exercise price - Grant price. Sale price can either be higher or lower than Exercise price. That small amount constitutes as Short Term (Same day sale) Capital Gains or Loss.

Restricted Stock:

Net Proceeds = Sale price * num of RS
Date of sale = Sale date

Cost basis = Vest price * num of RS
Date acquired = Vest date

W2 already mentions the income earned on the RS using Vest price on Vesting date.

More info:

- Search for "Understanding Restricted Stock" on Etrade if you have an account.
- NonQualified Stock Options.

Hope this helps.

Gmail productivity

2010-03-21T20:02:00.000-07:00

For a long time, I wanted a simple tool that would merge my to-do list, draft letters and reminders with my email system. About a year or so ago Gmail introduced some nifty features that let me do just that. So, I thought I'd share them with you (a yr later).

First, configure Multiple Inboxes:
Go to Gmail settings and select the Multiple Inboxes tab and then type this in. You just need 1 pane, so add this -in:trash AND (label:to-do OR in:drafts) as the Search query and call the Pane "To do".

[Update: May 9, 2011]

I now have 3 inboxes in addition to the main inbox. This needs 2 labels "to-do" and "constant"
Urgent:
-in:trash AND is:starred AND -label:constant

To do:
-in:trash AND -is:starred AND -label:constant AND (label:to-do OR in:drafts)

Long term/Constant reminders:
-in:trash AND -is:starred AND label:constant AND (label:to-do OR in:drafts)

Step 2 - Add a Filter to move those emails to the other Inbox:
Well this is all you will need. Don't worry, it's just 1 physical Inbox but different views to your emails.

Step 3 - Enjoy:

Now, you can just send a quick note to yourself from your Blackberry or office desktop to your Gmail account and it will go to the To do list. Even draft emails and blogs that you haven't finished writing will appear in this list. Cool huh?

Cheers!

2010-03-18T12:04:00.000-07:00

As the Maharishi said, let your mind wander...but carry your GPS along.

Digging up links to my old Event Stream Processor

2010-03-18T11:53:00.000-07:00

I was digging up links and articles to my old StreamCruncher hobby project. Cleaning up my bookmarks, rather.Here's what Google came up with (after some manual filtering):

- Paul Dekker's Master's thesis on Complex Event Processing with StreamCruncher, RuleCore and Esper as case studies

- Edson Tirelli's blog entry, one of the Drools guys

- An Introduction To Data Stream Query Processing from Truviso

- Creating an event driven SOA

- Marco on in-memory DBs for CEP

- The SQL debate on Financial Techinsider.

- Zepheira presentation

Later.

2010-03-16T21:28:00.001-07:00

Spring - yes, that season when annoying cyclists and bikers crawl out of the woodwork and make you drive slower.

Hawt diggity! So many key-value stores!

2010-03-16T20:24:00.000-07:00

A short list of in-process, key-value stores, mercifully not calling themselves NoSQL.

HawtDB - yet another key-value store. It's old fashioned B-Trees and it uses the same code base as ActiveMQ's file storage system.

SimpleDBM - as the author himself claims, it's fun to implement the old algorithms and see for your self.

Babudb - why another one, of course.

If someone thought of Lucandra (Lucene + Cassandra), then you ask how come there's no Prevayler + Lucene? Of course there is one. It's called Nodb. I wonder what happened to Prevayler.

And some other things I liked:

JD Java Decompiler - better than any I've seen so far.

If you love Apache Camel, then you'll love MycilaEvent. A simple and elegant in-memory publish-subscribe system.

Oh, before you go there's Seaglass - helping even the ugliest Swing UIs look insanely cool. If you thought Nimbus LF in Java 6 was good, this is even better. Remember the awesome Alloy LF but had to pay for? Good thing Seaglass is open source.

Cheers!