Edge brings a Flash-like development environment to HTML5. With timeline and direct scripting, developers can dig into HTML5 features without having to play much with the code.

Edge Features:

It is a comprehensive HTML5 Visual Editor

• Edge provides visual drawing and text tools, image importing, and a Flash-style timeline.
• Create animations of HTML content.

Eventualy, Adobe would bring more to the platform, especially on the canvas side of things. What’s coming more is the support for local storage, using which you would be able to create superb HTML5 web applications, within minutes.

This is the first HTML5 editor of this kind. Adobe sees the future, and won’t leave a chance of letting RIA web development go into another hands. Whatever, happens, consumers and developers are gain.

Watch an overview of Edge:

You can download the Edge beta right now, or just check out a few sample animations.

We write latest and greatest in Tech Guides, Apple, iPhone, Tablets, Android,  Open Source, Latest in Tech, subscribe to us @geeknizer on Twitter OR on Facebook Fanpage:

Your HTML5 webapp can be powerful enough to compete with the desktop version, but you might be limited byt eh performance advantages as your app runs in the browser, instead of native code. But good web development practices can definitely help you reach there.

Pau irish, a Google Employee, gets into details on how you can cut down the processing required for creating common things in Webapps: HTML5, CSS. He concentrates on CSS reflows, taking benefits of hardware aceclerated CSS, optimiations for Animations, and benchmarking techniques.

You can also checkout the full series of Microsoft’s presentation from MIX10 about HTML5 High-Performance best practices:

We write latest and greatest in Tech Guides, Apple, iPhone, Tablets, Android,  Open Source, Latest in Tech, subscribe to us@taranfx on Twitter OR on Facebook Fanpage:

IE9 vs Chrome 10 vs Firefox 4 Benchmark

Platform: Windows 7 32bit on a Intel i7 Macbook Pro, 4GB RAM.

We are not testing 64bit since IE9 has poor performance on 64bit as it still uses older javascript engine, while IE 9 32-bit is using the newer, more efficient Chakra JIT.

Benchmark Results:

V8 Benchmark results

Sunspider Benchmark Results:

Kraken Benchmark Results

Peacekeeper Benchmark:

Chrome 10 wins in 2 tests and Firefox 4 does in one, and IE & Chrome tie in sunspider test.

Browser Verdict

I really don’t think that JavaScript performance is an issue any more, its fairly fast enough to be handled by users. What matters more is better support for modern technologies like HTML5. When it comes to the support for modern technologies, Firefox & Chrome beat IE9 out of the scene. There is a huge set of features tha IE9 needs to learn from Chrome 10 & Firefox 4:

Application Cache (offline), Web Workers (threads in JavaScript), HTML5 Forms (validation mechanism, CSS3 selectors), JavaScript Strict Mode , ForeignObject (embed external content in SVG), SMIL Animations (SVG animations), File API, WebGL (3D), CSS3 Transitions (for animations), CSS3 Text Shadow, CSS3 Gradients, CSS3 Border Image, CSS3 Flex box model, ClassList APIs, FormData, HTML5 History API, Drag’n Drop from Desktop.

We write latest and greatest in Browsers: Chrome, Opera, Firefox, IE, and latest in Tech @taranfx and Facebook:

Adobe acknowledges this value and that’s why they have launched a product called “Wallaby” an experimental Flash-to-HTML 5 converter tool. Wallaby is a cross-platform Adobe AIR application that allows users to instantly convert Flash output (FLA files) to HTML5 via a simple drag and drop. It is available free for download.

Wallaby, which was first previewed last fall at Adobe’s Max 2010 developer conference, is a great tool.

Watch the demonstration from Adobe:

“We are making this available free on Adobe Labs as experimental technology; it’s something we hope to continue to iterate and get feedback on from customers,” said Tom Barclay, senior product manager for Flash Professional. “I’m interested in how useful this output is, what people intend to use it for, and whether this is something we should be supporting longer term in Flash Professional as another output option or publish setting.”

Since apple has always banged Adobe on flash, its actually a good tool to counter all those concerns. Now all the existing Flash apps, animations/content can be run on iOS devices like iPhone, iPad and iPod Touch, without any pain.

However, not all elements from the Flash files will translate into HTML5. But users would get the benefit of the overall design and motion graphic animations. What will not get translated would be the dynamic part like blend modes, filters, audio, video, and even ActionScript.

The output from HTML5 converter tool is essentially a combination of HTML, SVG (Scalable Vector Graphics), and CSS. The tool is mart enough to translate Vector graphics into SVG & bitmaps into JPEG files. Text can optionally be converted to SVG text, which is converted to plain text, otherwise. The Flash timeline is converted to a group of CSS animations. Scripting allows for batch processing of multiple FLA files.

To summarize:

Supported Flash Professional features: vector art and images; classic text; keyframes; MovieClips and graphics; classic, motion, and shape tweens; rollover buttons; and instance names.

Unsupported Flash Professional features: filters (except simple alpha); blend modes; dynamic masks; some TLF (Text Layout Framework) text; 3D transforms and 3D tween; audio and video; and ActionScript.

Wallaby is believed to work perfectly with Webkit based browsers: Safari, Chrome, iOS devices, Android, blacberry devices.

Adoobe says that by usign this tool you can get your baseline and get the animations, additional actionscript like features using Jquery in Dreamweaver.

In any case, this a great tool, and a great initiation from adobe which shows Adobe’s enthusiasm to develop better and richer web. Will this tool support full Flash Professional features in the future? We’ll know.

Related: Html5 Video Player that works on All Browsers, compatible with Flash

We write about Open Source, Programming, Web, Apple, iPhone, Android and latest in Tech @taranfxon Twitter or subscribe below:

Peer-to-peer streaming i.e.  voice/video frames are streamed directly between peers, without any server in between is actually possible with HTML5 specification. The result is lower latency and optimal network utilization.

Checkout the demo of HTML5 P2p communications below by ericsson:

ConnectionPeer API

ConnectionPeer API is under works for establishing direct connection between two peers, which is web browsers in this case. ConnectionPeer is a very thin protocol as it shunts out signaling and connection stuff to traditional HTTP.

ConnectionPeer establishes peer-to-peer connectivity, using the following steps:

1. Each peer sends out its own reachability information using the getLocalConfiguration method.
2. Next, they add the information about the other peer (obtained typically over HTTPS from the chat server) using addRemoteConfiguration method.
3. Next, p2p connection is established, allowing for streaming data to be exchanged between the peers. When established, an onConnect event is generated and allows the application to respond with the data it wants to send out. ConnectionPeer includes methods for streaming data over the connection. These are used to add real-time voice and video streams and even HTML5 p2p file transfers.

The ConnectionPeer works almost everywhere, whether you are behind proxy, NAT or firewall. Whether you are on a desktop browser or a mobile (Android, iPhone, Blackberry), it doesn’t care, works on all WebKit browsers.

The good part of the whole story is that  IETF and W3C are standardizing this peer-to-peer support in browsers to enable real-time voice and video communication without plug-ins.

Code snippet:

Swarmplayer is one of the examples of doing HTML5 p2p video. It adds a P2P transport protocol to Firefox that allows <video src=”p2p://” > functionality. P2P transport is BitTorrent compatible.

More to come on HTML5, Open Source, Youtube, Google via @taranfx on Twitter or Facebook Fanpage.

HTML5 is the most beautiful that that happened to the web. HTML 5 would eventually make webapps powerful and as capable as native apps, with Chrome’s Native client.

HTML5 Client-side Local Storage provides a great solution for database storage on the client side. There are some other interesting things that can  be done on the client side.

Improving site performance by caching in HTML5 Client storage

By intelligently storing web page CSS, Javascript files or Images locally, you can avail benefit of reduced network and server usage, resulting in page loading time improvements.

The HTML5 localStorage provides a basic client-side key-value database, storing only String objects, which does fine for Javascript and CSS, however it would not store binary data like Images.

The first step to achieve this is to encode binary image data into base64 ascii. Using OpinionatedGeek, you can base 64 encode your images. Once done, you would have to implement the Javascript and localStorage API to read & write your Images from the local client:

source: developerWorks
<script>
var hero;
if ( localStorage.getItem(‘heroImg’)) {
hero = localStorage.getItem(‘heroImg’);
}
else {
hero = ‘/9j/4AAQSkZJRgABAgAAZABkAAD/7    /…/    6p+3dIR//9k=’;
localStorage.setItem(‘heroImg’,hero);
}
document.getElementById(“hero-graphic”).src=’data:image/png;base64,’ + hero;
</script>

The corresponding HTML Image element:

<img id=”hero-graphic” alt=”Blog Hero Image” src=”" />

The caching in HTML5 local client storage is way more effective than browser’s caching.

However, through the implementation of HTML5 Local Storage, the browser now provides a mechanism to permanently store large chunks of data, while giving server side applications control and intelligence over the data store itself.

The possibilities of speeding webapps are just endless with this style of local storage for web components. You can save swf, css, js, anything that can be heavy for your website.

Refer toHTML5 localStorage API, visit the W3C specification page for Web Storage.

Download complete HTML of this example: HTML 5 Image caching.

p.s. there are certain Vulnerabilites in HTML 5 implementation with certain browser, watchout!

More to come on HTML5, Open Source, Youtube, Google via @taranfx on Twitter or Facebook Fanpage.

jsFiddle is a great webapp that lets you edit HTML, JavaScript, CSS just like a normal IDE like Dreamweaver would do, all the syntax highlighting. The screen gets divided into 4 sections: HTML, CSS, Javascript and Result (Preview) as show below:

You can also add resources, an Ajax echo backend, and auto load from a slew of JavaScript frameworks. It also includes some built-in  examples that you can use to see the great stuff such as Processing in action.

Lot of hard and good work has been put into the project using CodeMirror and MooTools. Kudos!

We write Latest Tech updates in Open Source, Programming, Java, Tech News find us on Twitter @taranfx or subscribe below:

Though few predict that HTML5 would kill Flash, it’s more evident that HTML5 will innovate new web applications co-existing with flash.

The Latest web application “SketchPad” let’s you do a lot in your web browser. I’m deeply impressed by the capability of this app.

Sketchpad by Mugtug is a Pixelmator-like application that has desktop like tools, colour selection, patterns, swatches, all built using HTML5 and CSS. The performance is pretty good even on Firefox. And on Chrome 5 it was as good as any Desktop app, perhaps faster than Photoshop.

However, The UI doesn’t seem to take input from touchscreen, I couldn’t get it to run on iPhone or Android. But it would be one killer app.

It will not replace your current desktop image editor,  but it’s a tool you must check out and admire for what it is.

We write about Open Source, Programming, Web, Apple, iPhone, Android and latest in Tech @taranfxon Twitter or subscribe below:

The PHP runtime has in fact been rewritten, but it comes with an extra effort: The PHP is translated to C++ (which is of course more efficient) which is then compiled with g++. The project is called HipHop and has been in development under great secrecy at Facebook for the past 2+ years.

With HipHop, Facebook claims to have reduced the CPU usage on average by about 50%. HipHop for PHP isn’t technically a compiler itself, rather a source code transformer. HipHop automatically transforms  PHP source code into highly optimized C++ and then uses g++ to compile it.

Apart from this, They have discussed the challenges faced while scaling a PHP application. Scripting languages like PHP, perl, etc are known to be far less efficient when it comes to CPU and memory usage than interpreted, compiled languages like C++, Java. All this creates it even harder to scale an application written in PHP.

Scaling Facebook is particularly challenging because almost every page view is a logged-in user with acustomized experience. When you view your home page we need to look up all of your friends, query their most relevant updates (from a custom service we’ve built called Multifeed), filter the results based on your privacy settings, then fill out the stories with comments, photos, likes, and all the rich data that people love about Facebook. All of this in just under a second. HipHop allows us to write the logic that does the final page assembly in PHP and iterate it quickly while relying on custom back-end services in C++, Erlang, Java, or Python to service the News Feed, search, Chat, and other core parts of the site.

Finding new ways to improve PHP performance isn’t a new concept. At run time the Zend Engine turns your PHP source into opcodes which are then run through the Zend Virtual Machine. Open source projects such as APC and eAccelerator cache this output and are used by the majority of PHP powered websites. There’s also Zend Server, a commercial product which makes PHP faster via opcode optimization and caching. Even compiling PHP isn’t a new idea, open source projects like Roadsend and phc compile PHP to C, Quercuscompiles PHP to Java, and Phalanger compiles PHP to .Net.

There’s in-depth discussion about how it works, at the source.

PHP is currently used by popular and large, dynamic web sites such as Facebook, WordPress.com and Digg.  It was viewed as one of the hottest new technologies in 2005, when venture capitalist Marc Andreessen, founder of Netscape and current Facebook board member, told the Wall Street Journal that “PHP is to 2005 what Java was to 1995.”

What is notable now is – This new effort from Facebook could mold into acceleration for the industry adoption of PHP. The biggest bottleneck is now gone for good.

We write about Open Source, Programming, Web, Apple, iPhone, Android and latest in Tech @taranfx on Twitter.

PHP offers a light-weight runtime for small-to-medium sized webapps. If you are not a PHP developer, you will be surprised to know that PHP doesn’t support multithreading natively, though there are ways to make it possible. People have often come up with solutions to mock multithreading but still PHP sucks at performance as far as large applications are concerned.

Update: Facebook’s PHP Runtime HipHop, now Open Source

Most industry applications fallback to either Java/J2ee or .NET when they are designing inherently-scalable, responsive in high-load, resilient applications.

However, big companies who had the PHP as base right from the start complain to ZEND for such a poorly performing runtime. And Facebook is the one who is in the deepest pains caused by all this.

After years of struggle, they have finally have rewritten the runtime to achieve the level of performance way beyond than what it does today. It took them approximately 2 years with some senior level programmers.

As SDTimes reports,

Core PHP team had been brought to Facebook‘s main campus. That team were forced to sign NDA’s, and taken to a very quiet, secluded meeting room where some cool new Facebook-backed open source project was described.

Well, I was able to put all the pieces together on this one, finally, and I now understand exactly what is up: Facebook has rewritten the PHP runtime from scratch.

Now, that sounds like a good work. But what is even better is that they are planning to make a big announcement of  open source-ing the new runtime on this Tuesday. In addition, it makes alot more sense that Facebook would release it’s own version of Compiler to accompany the runtime improvements.

Well, this is not something new for PHP. Zend has time and again ignored performance issues with PHP.  Evidence comes from Yahoo!, who had to take a similar step to make it possible to continue using PHP to power it’s apps.

Now this new effort from Facebook could mold into acceleration  for industry adoption for PHP. Well, I don’t have the numbers to conclude anything solid but it sure would be a good step.

We write about Open Source, Programming, Web, Apple, iPhone, Android and latest in Tech @taranfx on Twitter.

Till now, the most popular method for local storage had been limited potential HTTP cookies or Google Gears for a few. All Cookies can do is key-value pairs of strings that are stored locally in a text file of 4KB max. We definitely need a smarter solution that an industry wide standard can solve.

Out of all that comes bundled in HTML5, Client-side storage is probably one of the most talked about features: Both +ve and -ve — lot of criticism of it’s security, and +ve innovation.

Client-side storage is divided into 3 methodologies:

1. Session storage.
2. Local storage
3. Database storage

Let’s get into each one of them:

1. Session Storage

Session storage is way better than what cookies have to offer. With different implementations the max limit can be something sufficient of the order of few MBs.

Unlike Cookies Session data is not sent with every request. The advantage: request payload is minimal.
So how exatly do we write it? Here goes an example:

sessionStorage.setItem('userName', 'taranfx');              // defining the session variable
alert("Your user is: " + sessionStorage.getItem('userName'));// accessing it
alert("Hello " + sessionStorage.userName);                   // another way of accessing the variable
sessionStorage.removeItem('userName');                       // finally unset it

2. Local Storage

The localStorage JavaScript object is functionally identical to the sessionStorage object. They only differ in persistence and scope. Scope: localStorage data is accessible across all browser windows while sessionStorage data is confined to the browser window that it was created in.

Global Storage is a memory space given by the browser that websites can use to store persistent data that doesn’t need to be sent to the server. The data is accessible by JavaScript/AJAX and hence by Flash. this could be really handy for Flash Games:

globalStorage[''].foo = 'bar';               // foo will be accessible by any website
globalStorage['com'].foo1 = 'bar1';          // foo1 will be accessible by websites ending in '.com'
globalStorage['taranfx.com'].foo2 = 'bar2';  // foo2 will be accessible by taranfx.com

The specification was more insecure what different browsers implemented. They replaced global storage with local storage where you cannot specify domains; the data you store is automatically associated with the domain under which the script is running. This means strictly we will disallow XSS which is very important.

Persistence: The choice for Local Storage is obvious — the data persistence — data remains there even when the browser Window/Tab closes. Here’s how this can be done:

localStorage.setItem('userName', 'taranfx');                 // defining the localStorage variable
alert("Your user is: " + localStorage.getItem('userName'));  // accessing it
alert("Hello " + localStorage.userName);                     // another way of accessing the variable
localStorage.removeItem('userName');                         // finally unset it

3. Database Storage

Till now what we have discussed is limited to key-value pairs. But when you are dealing with a larger amount of data, database is the weapon of choice. So far, I think Safari is the only browser (correct me if wrong) to have implemented this feature. It uses SQLite database, which is light and fast with few limitations like lack of foreign key constraints.

Here is example code for accessing the local database:

var db = openDatabase("Database_Name", "Database_Version");
database.executeSql("SELECT * FROM taranfx", function(result1) {
  // do something with the resultset, there could be n no. of things
  database.executeSql("DROP TABLE taranfx", function(result2) {
    // do some more cleanup or blah
    alert("My second database query finished executing!");
   });
});

You can get a demo of this local database storage here (needs webkit nightly)Apart from the limited functionalities, it has some serious vulnerabilities Detailed in Vulnerabilities in HTML 5 and Future.

I believe, as HTML 5 finds its destiny in more and more web applications, they would become more powerful and capable. You can check our other Programming articles and Subscribe to us, discuss Technology, programming via Twitter @Taranfx - Join the dialogue.

Related:

• Vulnerabilities in HTML 5 and Future
• HTML 5 drops most awaited open source Video codec
• What is HTML 5 and FAQ. Will it kill Flash?
• Why choose JavaFX. How to Code. Benchmark Graphics, CPU, Memory

Let’s go by an example. Try accessing Gmail on iPhone or Android phone,  you will have notice some differences from what it used to be a month ago. The new thing worth noticing is the introduction of the offline access.

Gmail went down, offline in September, but credits to Gears, Gmail was still up and running with select Browsers. On the other side, iPhone Safari doesn’t have a Gears plugin, so how was it still running?

The answer lies with the HTML 5 standard, more specifically: the local database storage. Though HTML 5 is still in-progress, WebKit powered browsers, such as Safari, Mobile Safari, (and Firefox) have already adopted local database storage. This opens a new door of opportunities for developers to create and innovate subsequently to read from/write to a fully capable: Locally stored, Relational SQL database via the web browser itself.

Current Gmail’s iPhone release is the first web app that I’ve seen using the technology.

I foresee offline-access as an important feature for NextGen web applications: for speed and availability. Like Google believes with Chrome OS , we have, practically, continued to decrease the gap between desktop apps and their web  counterparts using technologies such as AJAX, Flash, JavaFX, Silverlight, etc. which have continued to push the hard limits.

But, despite all of the added functionality, web apps suffer from inherited old limitation – They don’t exist when you go off the line. Well, that’s about to change with HTML 5.

HTML 5 App with Local Storage:  Gmail

The iPhone doesn’t allow raw file access(I’m talking of Virgin iPhone), I’ll demonstrate Gmail’s use of HTML 5 via Safari on a standard OS X platform. First thing first, in order to get Google to serve the HTML 5 version of Gmail, we’ll change the User-Agent of our PC to match that used by the iPhone.

To fake iPhone’s Safari using Safari in Windows or Mac,  In Safari, click on Preferences, then go to Advanced tab. Check the checkbox for Show Develop menu in menu bar option. Exit from the Preference dialog window, a new “Develop” menu will show in the menu bar. Click on Develop, and then select User Agent in the pull down menu. Click to select Mobile Safari 3.0 – iPhone. Here is the resultant User-Agent:

Mozilla/5.0 (iPhone; U; CPU iPhone OS 3_0_0 like Mac OS X; en-us) AppleWebKit/525.18.1 (KHTML, like Gecko) Version/3.1.1 Mobile/5H11 Safari/525.20

Now next time we visit Gmail, the iPhone specific version of the app opens. And, the local database storage is automatically setup.

One thing that raises concern here is that the end-user is NOT informed of this. Data is being stored locally in plain text, and user is un-aware.  On the other side, Gears will at least mandate the end-user to acknowledge before it actually makes a copy of data, offline. The phone will carry a local copy of their email, which could be accessible to just anyone, if the phone was ever lost.

Now let’s see exactly what has been stored locally. The database is set up in the following location:

Windows: C:\Users\taranfx\AppData\Local\Apple Computer\Safari\Databases\https_mail.google.com_0\0000000000000001.db

Mac: /Users/taranfx/Library/Safari/Databases/http_mail.google.com_0/0000000000000001.db

New databases will be created for each separate Gmail account logged-in, each one gets an incremented number instead of “1″ that you see over there.  Now you might be thinking Which Database is that? It’s SQLite database. Surprisingly, there is no encryption, no protection, the database content can be viewed with any SQLLite compatible app: I used SQLite Browser. And the Results were alarming:

1. cached_contacts - Top 20 frequent contacts, including email address, names
2. cached_conversation_headers - Abbreviated content from email messages including the full subject, sender’s name and first sentence or two of the message.
3. cached_labels - User defined labels which can be assigned to emails.
4. cached_messages - Similar to cached_conversation_headers
5. cached_queries – Certain queries
6. unclearconfig_table - Application version number
7. hit_to_data – ??
8. log_store – Some logging info.

All are  shown in the screenshot below:

Now if someone gets access to your machine or mobile, you can guess the level of risk you are under.

Verdict:

Gears and HTML 5 represent great technologies, but  poorly implemented, and hence result in increased security risk.

Applications interface with local data storage via JavaScript API calls.  The calls, as per the specification,  are  restricted by the same origin policy to ensure that only the application which originally created the data, can then subsequently access it. When sites are vulnerable to XSS vulnerabilities, a remote attacker could gain access to local database storage and perform any type of  client-side SQL injection attacks.

Gmail might be currently suffering from any XSS vulnerabilities, as they had numerous times in the past. What’s more critical is the fact that XSS remains a too-common vulnerability and as developers adopt local database storage via HTML 5, we are sure to see plenty of vulnerable sites, which will place everyone at risk.  It is not just a privacy concern, it’s also a data integrity concern: What if an attacker can manage to write to the database just as easily as they can read from it?

Nothing more or less, I feel that the HTML 5 specification has a great deal to offer and it’s good to see it’s early adoption. But the fate of the game lies in the hands of the developers , who will have to ensure that powerful features such as local database storage do not expose end-users to increased threat.

I’ve been using HTTP and SOAP since several years new. REST is rather new. SOAP revolutionized RPC and loose coupling  beyond the restrictions posed by  earlier protocols. However off late I have been giving APIs and interfaces considerable thought and am leaning a lot more towards simple HTTP based APIs with an XML or JSON response format as opposed to SOAP. Let’s try to discuss all the aspects one by one.

Before we start, Let’s do a basic terminology headsup -

Although, in alst ffew years we saw growth of large no.  of Web Services, despite that the hype surrounding the SOAP has barely reduced. Internet architects have come up with a surprisingly good argument for pushing SOAP aside: there’s a better method for building Web services in the form of Representational State Transfer (REST).

REST is more of an old philosophy than a new technology. But a realization that came later in technology. Whereas SOAP looks to jump-start the next phase of Internet development with a host of new specifications, the REST philosophy espouses that the existing principles and protocols of the Web are enough to create robust Web services. This means that developers who understand HTTP and XML can start building Web services right away, without needing any toolkits beyond what they normally use for Internet application development.

In a RESTful architecture, the key resources are identified — Can be entities, collections, or anything else the designer seems worthy of having its own URI. The standard methods — in this case, the HTTP verbs — are mapped to resource-specific semantics. All resources implement the  same uniform interface. The dimension of content-types, which allows for different representations of resources (e.g. in both XML, HTML, and plain text), as well as the possibility of links to resources in resource representations. Use your imagination — e.g. the GET on /customer/4711 would return a document that contains a link to a specific /order/xyz.

I am seeing a lot of new web services are implemented using a REST style architecture these days rather than a SOAP one. Lets step back a second and put some light on what REST is.

What is a REST Web Service

Representational State Transfer or REST basically means that each unique URL is a representation of some object. You can get the contents of that object using an HTTP GET, to delete it, you then might use a POST, PUT, or DELETE to modify the object (in practice most of the services use a POST for this).

How Popular is REST?

All of the major webservices on the Internet now use REST: Twitter, Yahoo’s web services use REST, others include Flickr, del.icio.us, pubsub, bloglines, technorati, and several others. Both eBay and Amazon have web services for both REST and SOAP.

and  SOAP?

SOAP is mostly used for Enterprise applications to integrate wide types and no. of applications and another trend is to integrate with legacy systems, etc. On the Internet side of things — Google is consistent in implementing their web services using SOAP, with the exception of Blogger, which uses XML-RPC.

REST vs SOAP

The companies that use REST APIs haven’t been around for very long, and their APIs came out this year or last year mostly. So REST is definitely In-Vogue  for creating a web service.  But, lets face it — Use SOAP to wash, and you REST when your tired). The main advantages of REST web services are:

• Lightweight – not a lot of extra xml markup
• Human Readable Results
• Easy to build – no toolkits required

SOAP also has some advantages:

• Easy to consume – sometimes
• Rigid – type checking, adheres to a contract
• Development tools

Is SOAP Simple Object access really that  simple ? I guess a misnomer!

Let’s discuss all the point of comparisons –

API Flexibility & Simplicity
The key to the REST methodology is to write Web services using an interface that is already well known and widely used: the URI. For example, exposing a currency converter service, in which a user enters a currency quote symbol to return a real-time target currency price, could be as simple as making a script accessible on a Web server via the following URI: http://www.ExampleCurrencyBrokerage.com/convert?=us-dollar&value=100&target=pound

Any client or server application with HTTP support could easily call that service with an HTTP GET command. Depending on how the service provider wrote the script, the resulting HTTP response might be as simple as some standard headers and a text string containing the current price for the given ticker symbol. Or, it might be an XML document.

This interface method has significant benefits over SOAP-based services. Any developer can figure out how to create and modify a URI to access different Web resources. SOAP, on the other hand, requires specific knowledge of a new XML specification, and most developers will need a SOAP toolkit to form requests and parse the results.

Bandwidth Usage – REST is Lighter

Another benefit of the RESTful interface is that requests and responses can be short. SOAP requires an XML wrapper around every request and response. Once namespaces and typing are declared, a four- or five-digit stock quote in a SOAP response could require more than 10 times as many bytes as would the same response in REST.

SOAP proponents argue that strong typing is a necessary feature for distributed applications. In practice, though, both the requesting application and the service know the data types ahead of time; thus, transferring that information in the requests and responses is gratuitous.

How does one know the data types—and their locations in the response—ahead of time? Like SOAP, REST still needs a corresponding document that outlines input parameters and output data. The good part is that REST is flexible enough that developers could write WSDL files for their services if such a formal declaration was necessary. Otherwise, the declaration could be as simple as a human-readable Web page that says, “Give this service an input of some stock ticker symbol, in the format q=symbol, and it will return the current price of one share of stock as a text string.”

Security
Probably the most interesting aspect of the REST vs. SOAP debate is the security perspective. Although the SOAP camp insists that sending remote procedure calls (RPC) through standard HTTP ports is a good way to ensure Web services support across organizational boundaries. However,  REST followers argue that the practice is a major design flaw that compromises network safety. REST calls also go over HTTP or HTTPS, but with REST the administrator (or firewall) can discern the intent of each message by analyzing the HTTP command used in the request. For example, a GET request can always be considered safe because it can’t, by definition, modify any data. It can only query data.

A typical SOAP request, on the other hand, will use POST to communicate with a given service. And without looking into the SOAP envelope—a task that is both resource-consuming and not built into most firewalls—there’s no way to know whether that request simply wants to query data or delete entire tables from the database.

As for authentication and authorization, SOAP places the burden in the hands of the application developer. The REST methodology instead takes into account the fact that Web servers already have support for these tasks. Through the use of industry-standard certificates and a common identity management system, such as an LDAP server, developers can make the network layer do all the heavy lifting.

This is not only helpful to developers, but it eases the burden on administrators, who can use something as simple as ACL files to manage their Web services the same way they would any other URI.

REST ain’t Perfect
To be wise, REST ain’t perfect. It isn’t the best solution for every Web service. Data that needs to be secure should never be sent as parameters in URIs. And large amounts of data, like that in detailed purchase orders (POs), can quickly become cumbersome or even out of bounds within a URI.

And when It comes to attachments, SOAP is a solid winner. SOAP can transport your all text adn BINaries without a glitch. In such cases, SOAP is indeed a solid solution. But it’s important to try REST first and resort to SOAP only when necessary. This helps keep application development simple and accessible.

Fortunately, the REST philosophy is catching on with developers of Web services. The latest version of the SOAP specification now allows certain types services to be exposed through URIs (although the response is still a SOAP message). Similarly, users of Microsoft .NET platform can publish services so that they use GET requests. All this signifies a shift in thinking about how best to interface Web services.

Developers need to understand that sending and receiving a SOAP message isn’t always the best way for applications to communicate. Sometimes a simple REST interface and a plain text response does the trick—and saves time and resources in the process.

Type Handling
SOAP provides relatively stronger typing since it has a fixed set of supported data types. It therefore guarantees that a return value will be available directly in the corresponding native type in a particular platform. Incase of HTTP based APIs the return value needs to be de-serialized from XML, and then type-casted. This may not represent much effort, especially for dynamic languages. Infact, even incase of copmlex objects, traversing an object is very similar to traversing an XML tree, so there is no definitive advantage in terms of ease of client-side coding.

Client-side Complexity (Thinner Clients)
Making calls to an HTTP API is significantly easier than making calls to a SOAP API. The latter requires a client library, a stub and a learning curve. The former is native to all programming languages and simply involves constructing an HTTP request with appropriate parameters appended to it. Even psychologically the former seems like much less effort.

Testing and Troubleshooting
It is also easy to test and troubleshoot an HTTP API since one can construct a call with nothing more than a browser and check the response inside the browser window itself. No troubleshooting tools are required to generate a request / response cycle. In this lies the primary power of HTTP based APIs

Server-side Complexity
Most Programming languages make it extremely easy to expose a method using SOAP. The serialization and deserialization is handled by the SOAP Server library. To expose an object’s methods as an HTTP API can be relatively more challenging since it may require serialization of output to XML. Making the API Rest-y involves additional work to map URI paths to specific handlers and to import the meaning of the HTTP request in the scheme of things. Offcourse many frameworks exist to make this task easier. Nevertheless, as of today, it is still easier to expose a set of methods using SOAP than it is to expose them using regular HTTP.

Caching
Since HTTP based / Rest-ful APIs can be consumed using simple GET requests, intermediate proxy servers / reverse-proxies can cache their response very easily. On the other hand, SOAP requests use POST and require a complex XML request to be created which makes response-caching difficult

VERDICT

In the end I believe SOAP isn’t that simple, it requires greater implementation effort and understanding on the client side while HTTP based or REST based APIs require greater implementation effort on the server side. API adoption can increase considerably if a HTTP based interface is provided. Infact,  an HTTP-based API with XML/JSON responses represents the best of both breeds and is easy to implement on the server as well as easy to consume from a client.

For consuming web services, its sometimes a toss up between which is easier. For instance Google’s AdWords web service is really hard to consume (in CF anyways), it uses SOAP headers, and a number of other things that make it kind of difficult. On the converse, Amazon’s REST web service can sometimes be tricky to parse because it can be highly nested, and the result schema can vary quite a bit based on what you search for.

Which ever architecture you choose make sure its easy for developers to access it, and well documented. In the end when you host Web-service for the internet, it’s the client side complexity that matters most in attracting them to use your service. Choose wisely.

Ian Hickson wrote that he was reluctantly dropping the open standard due to opposition from Apple, and said the rival H.264 codec could also not be specified due to opposition from other browser vendors. This means HTML 5 will not specify a single codec for web development.

One of the key features of HTML 5 is its native handling of rich media such as video and audio. However, “there is no suitable codec that all vendors are willing to implement and ship”, Hickson wrote on the website of the Web Hypertext Application Technology (WHAT) Working Group, the coalition of companies working to develop HTML 5.

“I have therefore removed the two subsections in the HTML 5 spec in which codecs would have been required, and have instead left the matter undefined, as has in the past been done with other features like IMG and image formats,  and plugin APIs, or web fonts and font formats,” Hickson wrote.

Hickson said that Apple will not implement Ogg Theora for Quicktime video due to “lack of hardware support and an uncertain patent landscape”, although he acknowledged that he may have oversimplified the situation in that assessment.

Google has implemented both H.264 and Ogg Theora in Chrome. However, Google cannot provide the H.264 codec license to third-party distributors of Chromium, the Linux version of Chrome, and has indicated a belief that Ogg Theora’s quality-per-bit is not yet suitable for the volume handled by YouTube, according to Hickson.

Opera and Mozilla — the latter of whom has built Ogg Theora support into its recently released Firefox 3.5 — will not implement H.264 due to patent and licensing issues, and Microsoft has “not commented on their intent to support at all”, Hickson wrote.

Hickson suggested two future scenarios: one where Ogg Theora support and use increases to the point where Apple’s concern regarding patents is reduced, in which case Theora becomes the de facto codec for the web; and one where the relevant H.264 patents expire and that standard becomes freely available, in which case H.264 becomes the de facto technology.

“The situation for audio codecs is similar, but less critical, as there are more formats,” Hickson wrote. “Since audio has a much lower profile than video, I propose to observe the audio feature and see if any common codecs surface, instead of specifically requiring any. I will revisit this particular topic in the future when common codecs emerge.”

Hickson noted in his post that he was “incredibly sorry” about the state of video codecs in HTML 5. “This is a terrible situation for the spec to be in,” he wrote. “I wish we had good answers instead of this quagmirish deadlock.”

JavaFX is built on top of a mature Runtime that gives developer’s amazing features. Java being in market since several years, they now have a more sophisticated API.

Update: This Blog post is Winner of Java Blogging Contest.

So what is JavaFX Hype all about?

I first got to hear about JavaFX more than a year back when I attended Sun Tech days. It wasn’t very mature at that time and failed to catch my attention. It was this year in Feb, when I saw a momentum and maturity in this platform, which encouraged me to take my steps further.

JavaFX gives developers an amazing feature-Rich API which will help them build scalable, fully integrated, Rich Graphics, Animated applications for the web. The beauty of JavaFX lies in the fact that its base (JVM) is already installed on all computers(90%).

When I first saw the API, I was amazed that it had so much pre-built into the API. e.g. All the common transitions like fading, scrolling, perspective animations are built-in. All you need is the idea and you can be all set to make the most powerful web application.

Being a Java at heart, you can always integrate it with existing java applications. Imagine a Live graphic Rich market-watch client talks directly to a EJB server to fetch live quotes and prepare animated graphs of statistical data and analytics to help you invest for future.

The feature I loved the most was, “applications are draggable to desktop”. Since apps run in JVM of local machine, though they open in browser, they can be dragged and dropped to desktop without interrupting any operation or performance.

Here is What I intend to Cover:

1. Example: How to Code Web Gallery in Javafx

i. Basic Overview

ii. The Code

a. Brief on animation Terminologies

b. Basic Code.

c. Transitions.

2. Benchmarking

i. Hardware used.

ii. Invocation and Startup

a. Observations

b. JavaFX vs. Flash

c. Conclusion

iii. Animated Transitions and Full Image load:

a. Key Observations

b. Conclusion

3. Verdict

i. Pros and Cons.

Let’s start with an example.

1. Example: How to Code Web Gallery in JavaFX

Before we start, you can have a Quick look at what we are going to achieve over here. It’s a decent web gallery inspired by one of them demoed on Javafx site. I took that gallery and re-wrote most of it to achieve the following:

1. Redesign UI to match my taste and site’s theme.

2. Optimize the code to max possible.

I did the latter to Benchmark JavaFX’s capabilities, as described in a later section. For now let’s look at the basics of JavaFX application design. Before we start, Let’s look at what did I make.

The Gallery is a JavaFX Frontend GUI with a backend supported by java Flickr API. On Load, Flickr is queried with REST API as http://api.flickr.com/services/rest/?method=flickr.people.getPublicPhotos&user_id=24847938@N07&api_key={apiKey}&per_page={thunbLayout.count}

HereI am sending request to Flickr to return me all public Photos for the user_id specified and per page show me {thunbLayout.count} many results per page using my unique API key.

This metaData when loaded, loads the 1st page of thumbnails. On selection via keyboard or mouse click on a pic, it opens for medium size and fizes the aspect ratio on load. While image is loaded, it is animated with Fade transition effect built into JavaFx. Let’s look at the code and things will get more clearer.

ii. The Code

Before we start, lets get you familiar with Jargons.

a. Basic Animation Terminologies:

Like Flash, JavaFX uses the generalized concept of Animations by using standard animation industry jargons. The First thing to learn is using Stages and Scenes. Stage is the main/core Placeholder for your JavaFX application. Scene is an independent widget which fits into Stage. Multiple Scenes can be put inside stage but there will be only one stage per application.

b. The Basic Code:

JavaFX made it really easy to code. Here is the code syntax:

[code lang="javascript"]
var stage = Stage {
title: "Taranfx Gallery"
width: 840
height: 520
visible: false
style: StageStyle.TRANSPARENT
scene: bind scene
}

function run() {
initUI();
stage.visible = true;
// Set focus to background by default
bgRect.requestFocus();
}

[/code]

Here, run() Method is the default main method inside Main.fx class. So setting stage to visible, and getting the focus, does the job!

Now Let’s create scene for our thumbnails:

[code lang="javascript"]

var scene : Scene = Scene {
width: 840
height: 520
content: Group {
content: bind stageContent //defined below inside initUI()
clip: Rectangle {
width: bind layout.width
height: bind layout.height
arcWidth: 20
arcHeight: 20
}
}
fill: Color.TRANSPARENT
}; [/code]

And Instantiate the UI components:

[code lang="javascript"]

function initFrontUI() {

descTxt = Text {
x: bind layout.thumbX
y: bind layout.descTxtY
font: bind layout.descFont
wrappingWidth: bind (layout.thumbGroupW - 10)
content: bind description
fill: Color.WHITE
smooth: true
textOrigin: TextOrigin.TOP
clip: Rectangle { // calculations for layout
x: bind descText.x
y: bind (descText.y - 2)
width: bind (layout.width - 20)
height: bind ( layout.thumbGroupY - descTxt.y - 17)
}
}

stageContent = [
backRect, titleBar, nxtButton, bckButton, exitButton,
descTxt, thumbGroup, pageBttnGroup,
fullView, progressBar,fiv.saveBttn //names are self explanatory, last one is save button inside Scene Full Image view.
];

getImageData(); // Call Flickr REST API using standard Java Flickr API. Loads list of thumb image src, description, etc.
}[/code]

c. Transitions:

Now look at how Transitions are created. To achieve the animation effect, you have to play with the javafx.animation.Timeline, javafx.animation.KeyFrame. Again, these are generic words used in animation industry (same with Flash). If you are new to animation, let me define it for you. Timeline is the time scale of the animation which consists of number of frames through which animation will move. KeyFrame is the frame with concrete data i.e. Initial or final state of the animation and in-between the frames happens the transition that creates animated illusion. The animation used, when you select a thumbnail to view fullImage, is demonstrated below:

[code lang="javascript"]

var tL:Timeline = Timeline {
rate: bind tLRate with inverse
keyFrames: [
KeyFrame {
time: 1s
values: [ opacity => 1.0 tween Interpolator.LINEAR ]
canSkip: true
}
]
};

...

function fadeEffect() {

if(visible) { // javafx.scene.Node.visible, if current stage is visible, its set true.
tL.time = 0s;
tLRate = 1.0;
opacity = 0.2;
visible = true;
} else {
tL.time = 2s;
tLRate = -2.0;
opacity = 1.0;
}
tL.play();
}

[/code]

Animations are so easy to code. I just loved it.

I don’t trust any hypes, statistics till I test them on my own. Proceed with the next section and you will know what convinced me here.

.

2. Benchmarking the JavaFX (Gallery example):

i. Hardware used:

Notebook: Dell XPS

Processor: Intel Core 2 Duo 2.2Ghz @800Mhz FSB

RAM: 2.5GB

Graphics: Standard Intel extreme

(I have a Nvidia notebook as well but I wanted to test it on the onboard graphics to check how bad can it get.)

Tools: Netbeans 6.5, VisualVM 1.1

ii. Invocation & Startup:

JavaFX startup is pretty heavy for initial 10 seconds. During this interval, It is supposed to load a large number of underlying classes.

The main loader is com.sun.javafx.runtime.main.Main.class, packaged inside the distributable Jar. In a web browser, actual invocation starts from the javascript from URL “http://dl.javafx.com/1.2/dtfx.js”.
This Javascript looks for “Javafx” method inside the HTML <script> tag. In this tag, information about the “JAR to load” is present. JAVAFX runtime Main.class takes over the control and loads the Projectname_browser.jnlp which invokes the actual jar user classes i.e. com.taranfx.* in this case.
Before loading your Main class i.e. com.taranfx.Main.fx, it loads all the base underlying classes to support the Javafx features.

a. Observations:

My application had import for around 200 classes and 20 classes were defined under com.taranfx.*. The Total classes loaded after the start-up was nearing 4000.
If you look at the graph above, loaded classes for first peek was 2500. This is the point where JavaFX started reading my com.taranfx.* package. This means, at all times for JavaFX to start empty, it will need 2500 runtime classes. During this time, (almost 6 seconds), CPU utilization is max. On my Dual core it was able to eat upto 70% CPU though it was using only 7mb of heap.
If you look at the CPU graph, the second peek was incurred when my classes started executing. This was the time when Request for Flickr REST API was being generated. During this, CPU utilization of 27%, Heap size of 12mb was observed. The third CPU peek came when response from Flickr was received, and images were starting to appear. Loading of 50 images (10in a row x 5 in a column) took peek utilization of 25.5%. As clear from Memory utilization graph, Images were being loaded and heap size was increasing in steps till 20mb of which roughly 13mb was being used. Immediately after this, a substantially GC call reduced the memory overhead. (after this watever memory increase you see is because of my further operations in GUI, we will consider them in next section)

.

b. JavaFX vs. Flash
Now, I had a similar application in Flash ofcourse pretty different in layout, etc but similar functionality. Let’s compare those statistics with JavaFX.

It was roughly 40% at first peak with RAM usage of 4mb, and then 20% second peek with 10mb, and 3rd peek 29% with 19mb RAM.

c . Conclusion:
All the performance statistics were pretty close to Adobe Flash but were mostly on the higher side which is but obvious because its VM

.

iii. Animated Transitions and Full Image load:
So after loading of thumbnails is over, next comes the main application. Navigating quickly between images as it prepares requests for each of the image to be downloaded for preview. Let’s discuss the Performance of the application during power user usage. Since the application has lots of animations specially Fade transitions, We will compare how well are those can run on our machines.

Please note, I have chosen animation mainly as fade as it needs alot of CPU juice to run smoothly. Infact, smooth fading was far from reality in Swing. So let’s see how well JavaFX handles this in new refined JVM.

Let’s now look at the profiling:

a. Key Observations:

Refer to the CPU, the first wave peek you see is at approx. 15 seconds from when all thumbs were loaded. This peek was incurred due to my first click, which triggered the very first transitioning of fading all 50 thumbnails screen to Full Image preview (class ). Fading was very smooth and what a surprise it took just 19% of my CPU. Are you kidding me JavaFX ? Fading involves a number of interpolated frames during the transition time (set to 2 seconds) and frame rate of decent 20 fps was observed (I used a screen capture tool that auto-detects frame rate of the screen, it gave 20.3 fps)

Moving on, I became a power user (clicking madly on all images and then returning back) at full pace. Clicked images were being loaded in background threads while new images being licked were having fading transitions, one by one being put to backround thread queue to load images from flickr. As expected, it resulted in good CPU utilization, though transitions still remained smooth as before. CPU wasn’t kicked much it ranged between 30 to 60% which is pretty expected, no surprises. But one thing impressed me, Heap Usage. It didn’t eat much of the Heap. At start, Heap size was 20MB (15mb used), it then raised only to 25mb after 40 seconds of power user activity. GC wasn’t kicked more than once and it reduced Used heap from 20 to 15mb making it less hungry for more Heap. I must admit, memory management was pretty good.

Now let’s look at the other part, the most active Threads.

Java.util.concurrent.FutureTask.run() ate most of the CPU. Because of high number of requests, large no of threads got created, and for obvious reasons, this had to be the highest usage. Second highest is javax.swing.SystemEventQueueUtitlities, which is a old class from the generation of swings exposing some generic UI utilities. This involves the fading, and other graphical operations. Third was sun.rmi.transport.tcp.TCPTransport, this was for TCP connection to Flickr. The CPU usage for this thread is during translation of TCP requests from Java to right to your OS protocol stack.

b. Conclusion

I’m still left astonished if this was possible inside VM! The Ability of Graphics (atleast for 2D) is brilliant. Later on when I took the same test to Nvidia platform, I did see noticeable differences. The Fade effect had risen from bare 20fps to 28fps.

3. The VERDICT!

The Pros:

- Solid API with bundled inbuilt features for almost anything you will need.

- Brilliant Graphics Rendering (2D)

- Low on CPU usage than previous generation of JavaVMs.

- Comparble performance for generic RIA.

- Excellent memory management. (it’s not just standard VM memory management, there’s more to it.)

- OpenSource: A More open approach to RIA in the industry as compared to Flash, Silverlight like AJAX.

- Universal Language for Desktop, mobiles, other portables.

The Cons:

Nothing in the world is without Cons, even JavaFX has it:

- Graphics and multimedia are powerful on JavaFX, but it runs in JVM and not the real system, hence graphics can never be as powerful as native applications like Adobe Flash. The high complexity advanced 2D, 3D graphics will suffer significant performance hits inside VM. Such aplications will have more floating point calculations and More frequent memory allocation/de-allocations which will choke VM. (Though, for low complexity 2D, jaavaFX might beat Flash)

- Another -ve is for Video and High definition: The mediaplayer (via API) in JavaFX is able to attain a decent framerate of 24/25fps and CPU utilization goes to peak during this playback over SD (Standard definition). Now if you are looking for HD content to go via JavaFX, it’s not possible at this time. I used the same hardware as in the benchamark. CPU utilization goes to peak to achieve that framerate for SD.

For Playing 720p and 1080p HD content, VM came to the knees, failed to provide any tolerable frame rates. Definitely, needs lot of improvement in this sector. May be Sun can develop native APIs to interact for each Nvidia CUDA, ATI graphics Kernel for each platform to accelerate this. This could encourage 3d gaming in JavaFX. (though this is very hard to do and maintain keepin platform independence in mind.).

- A big challenge awaits javafx to reduce Load times. To load startup classes, it takes 10-20 seconds depending upon the application and CPU you are using. Flash is much faster at this.

Definitely I found my effort worth while after days of playing with JavaFX. I can proudly say it will stand as a clear challenger to Flash (provided few things improve, specially load times). From the past trend of Sun, it has innovated in every field of Java and will continue to do so. And now that It’s with Oracle and Larry Ellison, I don’t have a doubt about its future.

Future could be JavaFX. Are you Ready?

Get Started www.Javafx.com