Just Another Geek

Go for it.

2010-12-11T15:19:00.001-08:00

Google got biased this morning

2010-12-02T10:31:00.000-08:00

Google got just 4 results on first page for me. Above is the snapshot of it.

SEARCH ENGINE BASIC

2010-11-30T23:24:00.000-08:00

CONTD....

search.
relevance.
display.

* no crawling and indexing.
CONTD....

Happens-Before....Java Memory Model

2010-09-06T01:53:00.000-07:00

"Java Memory Model (JMM) defines a partial ordering called happens-before on all actions with the program. Actions are reads and writes to variables, locks and unlocks of monitors etc. To guarantee that the thread executing action B can see the results of action A, there must be happens before relationship between A and B. In the absence of happens-before ordering between two operations, the JVM is free to re-order them as it pleases (due to the fact that every processor has it's cache and it needs to flush to the main memory). A correctly synchronized program is one with no data races, correctly synchronized programs exhibits sequential consistency, meaning that all actions within the program appear to happen in a fixed, global order.

The rules for happens-before are:

Program order rule. Each action in a thread happens-before every action in that thread that comes later in the program order.
Monitor lock rule. An unlock on a monitor lock happens-before every subsequent lock on that same monitor lock.
Volatile variable rule. A write to a volatile field happens-before every subsequent read of that same field.
Thread start rule. A call to Thread.start on a thread happens-before any other rhread detects taht thread has terminated, either by successfully return from Thread.join or by Thread.isAlive returning false.
Interruption rule. A thread calling interrupt on another thread happens-before the interrupted thread detects the interrupt( either by having InterruptedException thrown, or invoking isInterrupted or interrupted).
Finalizer rule. The end of a constrcutor for an object happens-before the start of the finalizer for that obejct.
Transitivity. If A happens-before B, and B happens-before C, then A happens-before C.
"
Ref: Java Concurrency in Pratice

2010-08-30T11:52:00.000-07:00

I tried Google News today

2010-07-19T20:46:00.000-07:00

I tried Google News today by typing "google news" in URL bar in Google Crome. Google result shows:

Then I clicked third link "Google News - news.google.com" tab. The result was:

Broken code?

2010-06-14T20:34:00.000-07:00

mid = (low + high)/2

mid = low + ((high-low)/2)

mid,low and high are int.

What's the difference?

context: Java, C, C++
Ideas Appreciated!

Inactive for Couple of Days

2010-05-25T20:21:00.000-07:00

Due to large learning curve of new job, keeping myself busy with new environment and new people. Stepping ahead as a Senior Software Engineer, got more responsibility and need broader knowledge . Stopped working on Tellurium for a while.

Will be back in couple of days.

Tellurium-Reference is finally released

2010-05-05T11:47:00.000-07:00

With the extra effort from all the team members, tellurium-reference guide is finally released. Hats-off to Jian Fang's work.

Please take a look to our effort on how this framework is changing the era of web testing.

Tellurium-Reference Guide

Further reference link:
Wiki
Google Code
Tellurium Home Page

Tellurium: A new concept of UI testing

2010-04-17T18:40:00.000-07:00

It's great fun working on this innovative open source project. I have never contributed to any open source project before besides commenting "Awesome Project....Keep Going". But now it's no more like that.

Yeah, the TELLURIUM, a wonderful open source web testing framework which is build on top of Selenium framework but with different testing concept. We are working on to build our own core engine and consequently remove the Selenium. Most existing web testing framework focus on individual UI element such as links and buttons. Tellerium takes a new approach for automated web testing by using the concept of UI module.

UI module is a collection of UI elements grouped together. Tellurium is build on the foundation of UI module. The UI module makes it possible to build locators for UI elements at runtime. Tellurium is implemented using Groovy and Java. The test cases can be written in Java, Groovy, or pure DSL scripts. Tellurium enforce UI model separate for the test code, making refactoring easy.

I will definitely update more about TELLURIUM on up coming posts.

Memory Structure of Java Object

2010-04-17T00:03:00.000-07:00

Java Developer on their programming career came across memory management and think about how much memory is used by a Java object. Let’s start off with object copy. The shallow copy is the size occupied by a single Java object. On the other hand, deep copy takes into account the shallow copy of the object and the deep size of each object referenced by this object. So to know the deep size of the object, one should know the shallow size of the object.

Every object is aligned to an 8 byte granularity. The object except Array has two words header. First word has identity hash code and second work has a reference to the object’s class. So, new Object() will be using 8 byte of the heap for the two header words and nothing else because the Object class doesn’t have any fields. After 8 byte of header, the class attributes fallow. Attributes are always aligned in memory to their size. For example int are aligned to a byte granularity, and long are aligned to an 8 byte granularity. The cost to read 4 byte word from memory into a 4 byte register of the processor is much cheaper if the word is aligned to a 4 byte granularity.

The virtual machine organize attributes in a memory in the following order:

- double and long
- int and float
- short and char
- boolean and byte
- references

plus the primitive data types supported by the Java virtual machine are the numeric types, the boolean type (§3.3.4),1 and the returnAddress type (§3.3.3). The numeric types consist of the integral types (§3.3.1) and the floating-point types (§3.3.2). The integral types are:

- byte, whose values are 8-bit signed two's-complement integers
- short, whose values are 16-bit signed two's-complement integers
- int, whose values are 32-bit signed two's-complement integers
- long, whose values are 64-bit signed two's-complement integers
- char, whose values are 16-bit unsigned integers representing Unicode characters (§2.1)

And for the reference types and values, there are three kinds of reference types: class types, array types, and interface types. Their values are references to dynamically created class instances, arrays, or class instances or arrays that implement interfaces, respectively. A reference value may also be the special null reference, a reference to no object, which will be denoted here by null. The null reference initially has no runtime type, but may be cast to any type.

For better memory usages:

Class myTestClass {
byte a;
int c;
boolean d,
long e;
Object f;
}

If JVM didn’t re-order the attributes, the object memory layout would be:

[HEADER: 8 bytes] 8
[a: 1 byte ] 9
[padding: 3 bytes] 12
[c: 4 bytes] 16
[d: 1 byte ] 17
[padding: 7 bytes] 24
[e: 8 bytes] 32
[f: 4 bytes] 36
[padding: 4 bytes] 40

Here 14 byte would have been wasted with padding and the object would use 40 bytes of memory. By reordering the object using the above rules above, the in memory structure of the object becomes:

[HEADER: 8 bytes] 8
[e: 8 bytes] 16
[c: 4 bytes] 20
[a: 1 byte ] 21
[d: 1 byte ] 22
[padding: 2 bytes] 24
[f: 4 bytes] 28
[padding: 4 bytes] 32

This time, only 6 bytes are used for padding and the object uses 32 bytes memory
So the rule is “class attributes are ordered like this: first longs and doubles; then ints and floats; then chars and shorts; then bytes and booleans, and last the references. The attributes are aligned to their own granularity”.

Now we know how to calculate the memory used by any instance of a class that extends Object directly. One practical example is the java.lang.Boolean class. Here is its memory layout:

[HEADER: 8 bytes] 8
[value: 1 byte ] 9
[padding: 7 bytes] 16

An instance of the Boolean class takes 16 bytes of memory. Notice the padding at the end to align the object size to an 8 bytes granularity.

Another rule is “Fields that belong to different classes of the hierarchy are NEVER mixed up together. Fields of the superclass come first, obeying rule 2, followed by the fields of the subclass.”

class MySuperClass {
long a;
int b;
int c;
}

class MySubClass extends MySuperClass {
long d;
}

Now the instance of MySubClass in memory:

[HEADER: 8 bytes] 8
[a: 8 bytes] 16
[b: 4 bytes] 20
[c: 4 bytes] 24
[d: 8 bytes] 32

Another rule is “Between the last field of the superclass and the first field of the subclass there must be padding to align to a 4 bytes boundary.”

class MyClassOne {
byte a;
}

class MyClassTwo {
byte b;
}

[HEADER: 8 bytes] 8
[a: 1 byte ] 9
[padding: 3 bytes] 12
[b: 1 byte ] 13
[padding: 3 bytes] 16

Notice the 3 bytes padding after field a to align b to a 4 bytes granularity. That space is lost and cannot be used by fields of class MyClassTwo.

The final rule is applied to save some space when the first field of the subclass is a long or double and the parent class doesn't end in an 8 bytes boundary.
”When the first field of a subclass is a double or long and the superclass doesn't align to an 8 bytes boundary, JVM will break rule 2 and try to put an int, then shorts, then bytes, and then references at the beginning of the space reserved to the subclass until it fills the gap.”

Here is an example:
class MyClassFirst {
byte a;
}

class MyClassSecond {
long b;
short c;
byte d;
}

Memory layout is:

[HEADER: 8 bytes] 8
[a: 1 byte ] 9
[padding: 3 bytes] 12
[c: 2 bytes] 14
[d: 1 byte ] 15
[padding: 1 byte ] 16
[b: 8 bytes] 24

At byte 12, which is where class MyClassFirst 'ends', the JVM broke rule 2 and stuck a short and a byte before a long, to save 3 out of 4 bytes that would otherwise have been wasted.

Memory layout of arrays

Arrays have an extra header field that contain the value of the 'length' variable. The array elements follow, and the arrays, as any regular objects, are also aligned to an 8 bytes boundary.

Here is the layout of a byte array with 3 elements:

[HEADER: 12 bytes] 12
[[0]: 1 byte ] 13
[[1]: 1 byte ] 14
[[2]: 1 byte ] 15
[padding: 1 byte ] 16

And here is the layout of a long array with 3 elements:

[HEADER: 12 bytes] 12
[padding: 4 bytes] 16
[[0]: 8 bytes] 24
[[1]: 8 bytes] 32
[[2]: 8 bytes] 40

Memory layout of inner classes

Non-static inner classes have an extra 'hidden' field that holds a reference to the outer class. This field is a regular reference and it follows the rule of the in memory layout of references. Inner classes, for this reason, have an extra 4 bytes cost.

Final Words

We have learned how to calculate the shallow size of any Java object (32 bit Sun JVM). Knowing how memory is structured can help us understand how much memory is used by instances of our classes.

NoSQL (Not Only SQL) - Crazy Fast

2010-04-14T22:50:00.000-07:00

This is next generation database systems started development early 2009. The goal was non-relational, distributed, open source(I like this), schema free, replication support, easy API, eventually consistency, BASE (not ACID). Notable production implementations include Google's Big Table, Amazon's Dynamo and Cassandra(Facebook). Well known limitations include: limited support for dynamic queries and indexing, don't support JOIN like operations of SQL.

How to query NoSQL:
- key:value
- Row-id/Column-family:title[/time]
- "stella_12"/"dog":"name" -> Stella
- Graph Traversal
- API
- Query language
- Integration to indexing and search engines
- Map-Redue

Map-Reduce:

Map-Reduce is a programming model and associated implementation for processing and generating large datasets. Look at following Map-function:

function map(doc) {
if (doc[ 'type' ] == 'Dog') {
emit(doc[ 'mood' ], doc[ 'birthdate' ]);
}
}

It generates index view of data/document and this view is just another hash, but both key and value can be 'anything'.

Comparition with RDBMS:

- Strong consistency vs. Eventual Consistency
- Big dataset vs. HUGE dataset
- Scaling is possible vs. Scaling is easy
- SQL vs. Map-Reduce
- Good Availability vs. Very high availability

James Gosling left Oracle/Sun

2010-04-14T22:33:00.000-07:00

He said "Yes, indeed, the rumors are true: I resigned from Oracle a week ago (April 2nd)" and added "As to why I left, it's difficult to answer: Just about anything I could say that would be accurate and honest would do more harm than good.". What the second sentence he mentioned means? Should we aware about the future of Java? Many are commenting he can do better without Oracle. To how extend is that convenient? I mean, I am confused about whether he can do better or not. But still I always trust a GEEK like him and always hope for the best for them, wherever he goes, whatever he does would be innovative, definitely. On the other hand failure of Sun was the failure of James Gosling and he was also failed. But let's hope he never fails again although the failure is the part of success.