http://www.xmind.net

By Greg Luck - http://gregluck.com/blog/

The RESTful Ehcache Server is designed to achieve massive scaling using data partitioning - all from a RESTful interface. The largest ehcache single instances run at around 20GB in memory. The largest disk stores run at 100Gb each. Add nodes together, with cache data partitioned across them, to get larger sizes. 50 nodes at 20GB gets you to 1 Terabyte.Â
Two deployment choices need to be made: where is partitoning performed, and is redundancy required? These choices can be mixed and matched with a number of different deployment topologies.

This topology is the simplest. It does not use a load balancer. Each node is accessed directly by the cache client using REST. No redundancy is provided.Â
The client can be implemented in any language because it is simply a HTTP client. It must work out a partitioning scheme. Simple key hashing, as used by memcached, is sufficient.

Redundancy is added as shown in the above diagram by:

1. Replacing each node with a cluster of two nodes. One of the existing distributed caching options in ehcache is used to form the cluster. Options in ehcache 1.5 are RMI and JGroups-based clusters. Ehcache-1.6 will add JMS as a further option.
2. Put each ehcache cluster behind VIPs on a load balancer.

Interestingly, content-switching load balancers support URI routing using some form of regular expressions. So, you could optionally skip the client-side hashing to achieve partitioning in the load balancer itself.

What is IBM Thread and Monitor Dump Analyzer for Java?

During the run time of a Java™ process, some Java Virtual Machiness (JVMs) may not respond predictably and oftentimes seem to hang up for a long time or until JVM shutdown occurs. It is not easy to determine the root cause of these sorts of problems.

By triggering a javacore when a Java process does not respond, it is possible to collect diagnostic information related to the JVM and a Java application captured at a particular point during execution. For example, the information can be about the operating system, the application environment, threads, native stack, locks, and memory. The exact contents are dependent on the platform on which the application is running.

On some platforms, and in some cases, javacore is known as "javadump." The code that creates javacore is part of the JVM. One can control it by using environment variables and run-time switches. By default, a javacore occurs when the JVM terminates unexpectedly. A javacore can also be triggered by sending specific signals to the JVM. Although javacore or javadump is present in Sun Solaris JVMs, much of the content of the javacore is added by IBM and, therefore, is present only in IBM JVMs.

IBM Thread and Monitor Dump Analyzer for Java analyzes javacore and diagnoses monitor locks and thread activities in order to identify the root cause of hangs, deadlocks, and resource contention or monitor bottlenecks.

http://www.alphaworks.ibm.com/tech/jca?open&ca=drs-aw-jav&S_TACT=106AH21...

This specification describes the Web Application Description Language (WADL). WADL is designed to
provide a machine process-able description of HTTP-based Web applications.

1.1 Web Applications
For the purposes of this specification, a Web application is defined as a HTTP-based application whose
interactions are amenable to machine processing. While many existing Web sites are examples of HTTPbased
applications, a large number of those require human cognitive function for successful non-brittle1 use.
Typically Web applications:
• Are based on existing Web architecture and infrastructure
• Are platform and programming language independent
• Promote re-use of the application beyond the browser
• Enable composition with other Web or desktop applications

---
https://wadl.dev.java.net

Eclipse Flash Development
http://fdt.powerflasher.com/products/fdt-30/enterprise/

Scratch data is transient data that only has value while a workflow is incomplete. Applications are running rampant with it.
Here’s a real world example of scratch data that’s easy to understand. You can image a math test where you choose from multiple
choice answers, ‘A’, ‘B’, ‘C’ or ‘D’. Perhaps the scratch paper you use to arrive at the answer is not collected by the teacher at the
end of the test, and it therefore never becomes part of the official results, but without the scratch paper, you can’t take the test.
Furthermore, if you had to fill in a multiple choice form that somehow described all of your interim calculations, you might not be
able to complete the test in time!
Many of the applications that have scratch data today are operating in a load-balanced manner and are typically spread out across
more than one hardware machine / JVM. As a result of spreading the application across JVMs / servers, the scratch data inside
a lot of these applications is getting shoved into the database just in case traffic is routed incorrectly or in case a node fails. The
image below shows the problem graphically.
http://www.infoq.com/

Google is open sourcing the partial secret for fast communication and easier programming which is a pretty close to my PML implementation.
PML stands for Property Markup Language on which I started work some ten years ago and was using even professionally in different formats and versions.

The overview below sums it pretty much up. My version runs the lot with extensions and is tightly wrapped to the Java language with the difference that is really cross various JVM release compatible, beside hardware platform bytecode independent a run everywhere system. With PML you can prototype functionally an application in a RAD fashion to produce quick results. But my framework still needs lots of work and a team to make any notice.

So from computers to small gadgets this type of script format can be used and run lighting fast.

http://code.google.com/apis/protocolbuffers/docs/overview.html