Selenium - Web Test Automation Framework

Selenium automates browsers. That's it. What you do with that power is entirely up to you. Primarily it is for automating web applications for testing purposes, but is certainly not limited to just that. Boring web-based administration tasks can (and should!) also be automated as well.

Selenium is a package of various test components which consists of the following three major tools. Each one has a specific role in aiding the development of test automation for a Web application.

1. Selenium IDE – A Firefox extension to record test cases and suites.
2. Selenium RC – Used to run tests on different browsers and systems.
3. Selenium Grid – Runs multiple instances of Selenium RC at once.
4. Qualitia and Tellurium – A wrapper for the Selenium engine.

ref:

Selenium - http://code.google.com/p/selenium/

Selenium downloads - http://code.google.com/p/selenium/downloads/list

Selenium Documentation - http://code.google.com/p/selenium/wiki/Documentation

Getting Started with WebDriver - http://code.google.com/p/selenium/wiki/GettingStarted

WebDriver Wiki - http://code.google.com/p/selenium/w/list?q=label:WebDriver

TestNG Documentation - http://testng.org/doc/documentation-main.html

Selenium Open Source Test Automation Framework Implementation Guide - http://www.open2test.org/QAT_Tech_Docs/Selenium_framework_implementation_guide.pdf

Selenium Tutorials and Videos - http://qtpselenium.com/selenium-tutorial/selenium-webdriver-example/

Introducing Webdriver - http://google-opensource.blogspot.com/2009/05/introducing-webdriver.html

Design Patterns that have worked well on WebDriver projects - http://code.google.com/p/selenium/wiki/DesignPatterns

Miscellaneous -
http://qaselenium.blogspot.com/

Multi-Tenant Architecture

Multitenancy refers to a principle in software architecture where a single instance of the  software runs on a server, serving multiple client organizations (tenants). Multitenancy is contrasted with a multi-instance architecture where separate software instances (or hardware systems) are set up for different client organizations. With a multitenant architecture, a software application is designed to virtually partition its data and configuration, and each client organization works with a customized virtual application instance. Multitenancy is also regarded as one of the essential attributes of cloud computing.

Differentiation from Virtualization:

In a multitenancy environment, multiple customers share the same application, running on the same operating system, on the same hardware, with the same data-storage mechanism. The distinction between the customers is achieved during application design, thus customers do not share or see each other's data. Compare this with virtualization where components are abstracted enabling each customer application to appear to run on a separate physical machine.

Approaches to Managing Multi-Tenant Data:

1. Separate Databases
2. Shared Database, Separate Schemas
3. Shared Database, Shared Schema

Hybrid Multi-Tenant Database Architecture:

1. Single Tenant - While this approach offers customers a separate custom database, it does not allow for a scalable solution thereby requiring software vendors to maintain multiple highly variable database schemas making software upgrades more difficult and restricting the ability of the vendor to maintain one core code base.
2. Multi-Tenant with Identical Schemas - While this approach offers substantial scalability, it limits the breadth of configuration options for each individual customer forcing them to cope with limited business process support from the application.
3. Multi-Tenant with Custom Schemas - While this approach offers a wide range of configuration options for the customer, it limits the vendor's ability to maintain one core code base and/or forces the vendor to introduce customer specific complexity into the master code line potentially impacting performance.

ref:

Wiki - http://en.wikipedia.org/wiki/Multitenancy

Multi-Tenant Data Architecture - http://msdn.microsoft.com/en-us/library/aa479086.asp

Architectural Multi-Tenancy - https://devcentral.f5.com/weblogs/macvittie/archive/2010/05/18/architectural-multi-tenancy.aspx

Convert your web application to a multi-tenant SaaS solution - http://www.ibm.com/developerworks/cloud/library/cl-multitenantsaas/

An Open Multi-Tenant Architecture to Leverage SMEs - http://www.europeanjournalofscientificresearch.com/ISSUES/EJSR_65_4_14.pdf

A Multi-Tenant Architecture for Business Process Execution - http://people.apache.org/~hemapani/research/papers/ode-multi-tenancy.pdf

Securing Multi-Tenancy and Cloud Computing - http://www.juniper.net/us/en/local/pdf/whitepapers/2000381-en.pdf

SaaS strategies for Software Delivery - http://msdn.microsoft.com/en-us/library/aa479069.aspx

AngularJS - OpenSource JavaScript Framework

AngularJS is an open-source JavaScript framework. Its goal is to augment browser-based applications with Model–View–Controller (MVC) capability, reduce the amount of JavaScript needed to make web applications functional. These type of apps are also known as Single-Page Applications.

The Philosophy of Angular:

Angular is built around the belief that declarative programming is better than imperative programming when it comes to building UIs and wiring software components together, while imperative code is excellent for expressing business logic.

Design goals:

1. Decouple DOM manipulation from app logic. This improves the testability of the code.
2. Regard app testing as equal in importance to app writing. Testing difficulty is dramatically affected by the way the code is structured.
3. Decouple the client side of an app from the server side. This allows development work to progress in parallel, and allows for reuse of both sides.
4. Guide developers through the entire journey of building an app: from designing the UI, through writing the business logic, to testing.
5. Make common tasks trivial and difficult tasks possible.

Notable Features:

1. Two Way Data-Binding
2. Templates
3. MVC
4. Dependency Injection
5. Derivatives

Notable Angular Directives:

1. ng-repeat: Instantiate an element once per item from a collection.
2. ng-show & ng-hide: Conditionally show or hide an element, depending on the value of a boolean expression.
3. ng-switch: Conditionally instantiate one template from a set of choices, depending on the value a selection expression.

ref:

AngularJS Home Page - http://angularjs.org/

AngularUI Home Page - http://angular-ui.github.com/

AngularJS Wiki - http://en.wikipedia.org/wiki/AngularJS


Developing an AngularJS Application with HTML5 Socket.IO - http://www.html5rocks.com/en/tutorials/frameworks/angular-websockets/

Apache Mahout - Scalable Machine Learning Algorithms

Apache Mahout is a new open source project by the Apache Software Foundation (ASF) with the primary goal of creating scalable machine-learning algorithms that are free to use under the Apache license. The project is entering its second year, with one public release under its belt. Mahout contains implementations for clustering, categorization, CF, and evolutionary programming. Furthermore, where prudent, it uses the Apache Hadoop library to enable Mahout to scale effectively in the cloud.

ref:

Apache Mahout Wikipedia - http://en.wikipedia.org/wiki/Apache_Mahout

Apache Mahout Wiki - https://cwiki.apache.org/MAHOUT/mahout-wiki.html

What is Apache Mahout - http://mahout.apache.org/ 

Introducing Apache Mahout - http://www.ibm.com/developerworks/java/library/j-mahout/

Introduction to Apache Mahout - http://www.slideshare.net/gsingers/intro-to-mahout-dc-hadoop

Data Mining using Mahout - http://search.iiit.ac.in/cloud/presentations/8.pdf

Apache Mahout: a formidable collection of Data mining algos on the top of Hadoop (Map Reduce) - http://codingplayground.blogspot.com/2010/08/apache-mahout-formidable-collection-of.html

Machine Learning using Mahout - http://www.slideshare.net/gsingers/intro-to-apache-mahout

IBM Hadoop and Mahout online resources - http://www.ibm.com/developerworks/java/library/j-mahout/#resources

Apache Hadoop - An open source implementation of MapReduce programming model

Apache Hadoop is an open-source software framework written in Java for distributed storage and distributed processing of very large data sets on computer clusters built from commodity hardware.

MapReduce, a programming model and implementation developed by Google for processing massive-scale, distributed data sets. Apache Hadoop is an open source MapReduce implementation software framework that supports running data-intensive distributed applications on large cluster built of commodity hardware.

Apache Hadoop is an open source software framework that supports data-intensive distributed applications licensed under the Apache v2 license. It enables applications to work with thousands of computational independent computers and petabytes of data. Hadoop was derived from Google's MapReduce and Google File System (GFS) papers. Hadoop is a top-level Apache project being built and used by a global community of contributors, written in the Java programming language. Yahoo! has been the largest contributor^[3] to the project, and uses Hadoop extensively across its businesses.

Apache Hadoop is a framework for running applications on large cluster built of commodity hardware. The Hadoop framework transparently provides applications both reliability and data motion. Hadoop implements a computational paradigm named Map/Reduce, where the application is divided into many small fragments of work, each of which may be executed or re-executed on any node in the cluster. In addition, it provides a distributed file system (HDFS) that stores data on the compute nodes, providing very high aggregate bandwidth across the cluster. Both MapReduce and the Hadoop Distributed File System are designed so that node failures are automatically handled by the framework.

As a conceptual framework for processing huge data sets, MapReduce is highly optimized for distributed problem-solving using a large number of computers. The framework consists of two functions, as its name implies. The map function is designed to take a large data input and divide it into smaller pieces, which it then hands off to other processes that can do something with it. The reduce function digests the individual answers collected by map and renders them to a final output.

In Hadoop, you define map and reduce implementations by extending Hadoop's own base classes. The implementations are tied together by a configuration that specifies them, along with input and output formats. Hadoop is well-suited for processing huge files containing structured data. One particularly handy aspect of Hadoop is that it handles the raw parsing of an input file, so that you can deal with one line at a time. Defining a map function is thus really just a matter of determining what you want to grab from an incoming line of text.

HDFS(Hadoop Distributed File System): a distributed file-system that stores data on commodity machines, providing very high aggregate bandwidth across the cluster.

HDFS is so good for -

• Storing large files
• Terabytes, Petabytes, etc...
• Millions rather than billions of files 100MB or more per file
• Streaming data
• Write once and read-many times patterns
• Optimized for streaming reads rather than random reads
• Append operation added to Hadoop 0.21
• “Cheap” Commodity Hardware
• No need for super-comp

HDFS is not so good for - 

• Low-latency reads
• High-throughput rather than low latency for small chunks of data
• HBase addresses this issue
• Large amount of small files
• Better for millions of large files instead of billions of small files
• For example each file can be 100MB or more
• Multiple Writers
• Single writer per file
• Writes only at the end of file, no-support for arbitrary offset

pig vs hive:

Pig is a language for expressing data analysis and infrastructure processes. Pig is a platform for analyzing large data sets that consists of a high-level language for expressing data analysis programs, coupled with infrastructure for evaluating these programs. Pig is translated into a series of MapReduce jobs that are run by the Hadoop cluster. Pig is extensible through user-defined functions that can be written in Java and other languages. Pig scripts provide a high level language to create the MapReduce jobs needed to process data in a Hadoop cluster.

Apache Hive provides a data warehouse function to the Hadoop cluster. Through the use of HiveQL you can view your data as a table and create queries like you would in a database. To make it easy to interact with Hive we use a tool in the Hortonworks Sandbox called Beeswax. Beeswax gives us an interactive interface to Hive. We can type in queries and have Hive evaluate them for us using a series of MapReduce jobs.

PIG is a procedural data-flow language. A procedural language is executing step-by-step approach defined by the programmers. You can control the optimization of every step. HIVE looks like SQL language. Thus, it becomes declarative language. You can specify what should be done rather how should be done. Optimization is difficult in HIVE since HIVE depends on its own optimizer

ref:

MapReduce: Simplified Data Processing on Large Clusters - http://static.usenix.org/events/osdi04/tech/full_papers/dean/dean.pdf

Apache Hadoop Goes Realtime at Facebook - http://borthakur.com/ftp/RealtimeHadoopSigmod2011.pdf

Java development 2.0: Big data analysis with Hadoop MapReduce - http://www.ibm.com/developerworks/java/library/j-javadev2-15/index.html

To Hadoop, or not to Hadoop - https://www.ibm.com/developerworks/mydeveloperworks/blogs/theTechTrek/entry/to_hadoop_or_not_to_hadoop2?lang=en

What is Hadoop - http://www-01.ibm.com/software/data/infosphere/hadoop/

Distributed data processing with Hadoop, Part 1: Getting started - http://www.ibm.com/developerworks/linux/library/l-hadoop-1/

Distributed data processing with Hadoop, Part 2: Going further - http://www.ibm.com/developerworks/linux/library/l-hadoop-2/

Distributed data processing with Hadoop, Part 3: Application development - http://www.ibm.com/developerworks/linux/library/l-hadoop-3/

An introduction to the Hadoop Distributed File System - http://www.ibm.com/developerworks/web/library/wa-introhdfs/

Scheduling in Hadoop - http://www.ibm.com/developerworks/linux/library/os-hadoop-scheduling/index.html

Using MapReduce and load balancing on the cloud - http://www.ibm.com/developerworks/cloud/library/cl-mapreduce/

Intel Big Data - http://www.intel.com/bigdata

Apache Hadoop Framework Spotlights - http://www.intel.com/content/www/us/en/big-data/big-data-apache-hadoop-framework-spotlights-landing.html

Hadoop Books - https://drive.google.com/folderview?id=0B_hC-3L4eq17VFZfdVE0Z2NCUzQ&usp=sharing_eid

Hadoop Training Videos -

1. Hortonworks Apache Hadoop popular videos - https://www.youtube.com/watch?v=OoEpfb6yga8&list=PLoEDV8GCixRe-JIs4rEUIkG0aTe3FZgXV
2. Cloudera Apache Hadoop popular videos - https://www.youtube.com/watch?v=eo1PwSfCXTI&list=PLoEDV8GCixRddiUuJzEESimo1qP5tZ1Kn
3. Stanford Hadoop Training material - https://www.youtube.com/watch?v=d2xeNpfzsYI&list=PLxRwCyObqFr3OZeYsI7X5Mq6GNjzH10e1
4. Edureka Hadoop Training material - https://www.youtube.com/watch?v=A02SRdyoshM&list=PL9ooVrP1hQOFrYxqxb0NJCdCABPZNo0pD
5. Durga Solutions Hadoop Training material - https://www.youtube.com/watch?v=Pq3OyQO-l3E&list=PLpc4L8tPSURCdIXH5FspLDUesmTGRQ39I

Miscellaneous:

• The Hadoop wiki provides community input related to Hadoop and HDFS.
• The Hadoop API site documents the Java classes and interfaces that are used to program to Hadoop and HDFS.
• Wikipedia's MapReduce page is a great place to begin your research into the MapReduce framework.
• Visit Amazon S3 to learn about Amazon's S3 infrastructure.
• The developerWorks Web development zone specializes in articles covering various web-based solutions.

       Get products and technologies

• The Hadoop project site contains valuable resources pertaining to the Hadoop architecture and the MapReduce framework.
• The Hadoop Distributed File System project site offers downloads and documentation about HDFS.
• Venture to the CloudStore site for downloads and documentation about the integration between CloudStore, Hadoop, and HDFS.

       Discuss

• Create your My developerWorks profile today and set up a watch list on Hadoop. Get connected and stay connected withdeveloperWorks community.
• Find other developerWorks members interested in web development.
• Share what you know: Join one of our developerWorks groups focused on web topics.
• Roland Barcia talks about Web 2.0 and middleware in his blog.
• Follow developerWorks' members' shared bookmarks on web topics.
• Get answers quickly: Visit the Web 2.0 Apps forum.
• Get answers quickly: Visit the Ajax forum.

NoSQL Databases

What is NoSQL?

NoSQL database management systems are useful when working with a huge quantity of data and the data's nature does not require a relational model for the data structure. The data could be structured, but it is of minimal importance and what really matters is the ability to store and retrieve great quantities of data, and not the relationships between the elements. For example, to store millions of key-value pairs in one or a few associative arrays or to store millions of data records. This is particularly useful for statistical or real-time analyses for growing list of elements (such as Twitter posts or the Internet server logs from a big group of users).

Advantages of NoSQL databases:

• Horizontally Scalable
• Schema-less
• Cloud Model

NoSQL Categories:

The current NoSQL world fits into 4 basic categories -

1. Key-values Stores are based primarily on Amazon's Dynamo Paper which was written in 2007. The main idea is the existence of a hash table where there is a unique key and a pointer to a particular item of data. These mappings are usually accompanied by cache mechanisms to maximize performance.
2. Column Family Stores were created to store and process very large amounts of data distributed over many machines. There are still keys but they point to multiple columns. In the case of BigTable (Google's Column Family NoSQL model), rows are identified by a row key with the data sorted and stored by this key. The columns are arranged by column family.
3. Document Databases were inspired by Lotus Notes and are similar to key-value stores. The model is basically versioned documents that are collections of other key-value collections. The semi-structured documents are stored in formats like JSON.
4. Graph Databases are built with nodes, relationships between notes and the properties of nodes. Instead of tables of rows and columns and the rigid structure of SQL, a flexible graph model is used which can scale across many machines.

Major NoSQL Players

The major players in NoSQL have emerged primarily because of the organizations that have adopted them. Some of the largest NoSQL technologies include:

1. CouchDB: CouchDB is a database that uses JSON for documents, JavaScript for MapReduce queries,and regular HTTP for an API
2. MongoDB: MongoDB(from "humongous") is a scalable, high-performance, open source NoSQL database. Written in C++
3. SimpleDB: SimpleDB is a highly available and flexible non-relational data store that offloads the work of database administration. Developers simply store and query data items via web services requests and Amazon SimpleDB does the rest.
4. BigTable: BigTable is Google's proprietary column oriented database. Google allows the use of BigTable but only for the Google App Engine.
5. Dynamo: Dynamo was created by Amazon.com and is the most prominent Key-Value NoSQL database. Amazon was in need of a highly scalable distributed platform for their e-commerce businesses so they developed Dynamo. Amazon S3 uses Dynamo as the storage mechanism.
6. Cassandra: Cassandra was open sourced by Facebook and is a column oriented NoSQL database.
7. Neo4J: Neo4j is an open source graph database.

ref:

NoSQL Databases - http://en.wikipedia.org/wiki/NoSQL

Document Oriented Databases -  http://en.wikipedia.org/wiki/Document-oriented_database 

NoSQL and Document Oriented Databases -  http://ruby.about.com/od/nosqldatabases/a/nosql1.htm 

NoSQL Databases - http://newtech.about.com/od/databasemanagement/a/Nosql.htm

10 things you should know about NoSQL databases - http://www.techrepublic.com/blog/10things/10-things-you-should-know-about-nosql-databases/1772

What is a document database - http://dssresources.com/faq/index.php?action=artikel&id=236 

Top NoSQL Databases - http://opensourcebyte.blogspot.com/2012/01/top-nosql-databases.html

Mobile Application Development

Mobile Application Development is the process by which application software is developed for low-power handheld devices, such as personal digital assistants, enterprise digital assistants or mobile phones. These applications are pre-installed on phones during manufacture, can be downloaded by customers from various mobile software distribution platforms, or web applications delivered over HTTP which use server-side or client-side processing (e.g. JavaScript) to provide an "application-like" experience within a Web browser.

Execution Environments:
Android, iOS, BlackBerry, HP webOS, Symbian OS, Bada from Samsung, and Windows Mobile support typical application binaries as found on personal computers with code which executes in the native machine format of the processor (the ARM architecture is a dominant design used on many current models). Windows Mobile can also be compiled to x86 executables for debugging on a PC without a processor emulator, and also supports the Portable Executable (PE) format associated with the .NET Framework. Windows Mobile, Android, HP webOS and iOS offer free SDKs and integrated development environments to developers.

Mobile Web apps vs. Mobile Native apps: 
Is it better to deploy web apps or native apps? The answer is: both. Thanks to the recent improvements in the browsers of smartphones and tablet computers, web apps on mobile devices work well. Native apps do provide more access to native hardware features at this time. However, the decision isn't only about which is better. Users who are test-driving new solutions are hesitant to install a native application. Some are simply not ready to commit to our solution. They want to test-drive it before they install a native application. And native apps do require some maintenance and updates. By supporting both web apps and native apps, we can maintain a zero-install policy for our innovation. Also, users cycle through more devices than you might expect. When they get a new device, they test-drive it first with the web app before they install a native app. There are always trade-offs among function, design, and time to deploy.

Popular cross platform mobile frameworks:
Rhodes - is a Ruby-based framework that allows you to build your application a very similiar way to the way you’d build a Ruby Application. It offers support for iPhone, Android, BlackBerry, Windows Mobile, and Windows Phone 7.

Titanium Mobile by Appcelerator - Take your hard won web skills and turn them into mobile app development skills. It boasts support for letting you use JavaScript, HTML, and CSS. It features a JavaScript API that provides access to native UI elements. The magic in Titanium happens during runtime in it’s bridge between the JavaScript and the native SDK. The bridge reads your JavaScript and uses it to build views that have the same features and performance as an application written in that native language. Currently, Titanium Mobile supports iPhone and Android (with BlackBerry support in beta mode for paid subscribers).

MoSync - Takes a different approach to cross-platform mobile development in that it doesn’t use web technologies at all. It has it’s own SDK built with C/C++ that gives the developer access to many of the standard C libraries, graphic and media classes, the networking layer, native UI elements and more. At this point, it offers support for the Java ME environment, Windows Mobile, Symbian S60, Android, iOS, and Moblin/MeeGo. BlackBerry and Windows 7 support is coming soon. Just like RhoMobile, MoSync is more enterprise focused and you won’t find a lot applications in the app stores built with MoSync.

PhoneGap - Wraps a mobile web application exposing access to device features through a consistent API; it uses JavaScript as an abstraction layer between your mobile Web app and the device. PhoneGap currently supports iOS, Android, BlackBerry, webOS, Windows Mobile, Symbian, and Bada.

Other frameworks - Mono, Bada ...

ref:
Mobile Application Development - http://en.wikipedia.org/wiki/Mobile_application_development

Mobile Development Resources(Blogs/...) - http://www.shawngrimes.me/2012/03/mobile-development-overview/

How to approach mobile development today - http://blogs.msdn.com/b/obloch/archive/2012/03/08/how-to-approach-mobile-development-today.aspx 

Apple Roadmap to start developing iOS Apps  - https://developer.apple.com/library/ios/#referencelibrary/GettingStarted/RoadMapiOS/Introduction/Introduction.html

Becoming iOS Developer(by Josh Smith) - http://joshsmithonwpf.wordpress.com/2012/02/19/becoming-an-ios-developer/

Getting Started with the Mobile SDK for iOS - http://wiki.developerforce.com/

OS X Developer Library - https://developer.apple.com/library/mac/#documentation/General/Conceptual/ConcurrencyProgrammingGuide/Introduction/Introduction.html#//apple_ref/doc/uid/TP40008091-CH1-SW1

Beginner's guide to Mobile Web Development - http://mobiforge.com/starting/story/a-beginners-guide-mobile-web-development

Mobile Development SDKs compared - http://www.softwaresweden.com/2010/02/16/mobile-development-sdks-compared-mosync-phonegap-and-appwhirl/

Cross Platform Mobile Development Frameworks - http://floatlearning.com/2011/07/which-cross-platform-framework-is-right-for-me/

5 Cross-Platform Mobile Development Tools You Should Try - http://mashable.com/2010/08/11/cross-platform-mobile-development-tools/

Identify Memory Leaks and Memory Corruption in VC++ Application

Identify Memory Corruption: 

1.gflags (part of Windows Debugging Tools) tool can be used to find Memory Corruption issues. All we need is to download Windows Debugging tools(which comes with both gflags.exe & WinDbg).

ref: http://blogs.msdn.com/b/webdav_101/archive/2010/06/22/detecting-heap-corruption-using-gflags-and-dumps.aspx

Identify Memory Leaks: 
1. Visual Leak Detector tool is a free, robust, open-source memory leak detection system for Visual C++. After installing it, you just need to tell Visual C++ where to find the included header(vld.h) and library file(vld.lib). 
ref: http://vld.codeplex.com/, http://www.codeproject.com/Articles/9815/Visual-Leak-Detector-Enhanced-Memory-Leak-Detectio

2. Debugdiag is a Debug Diagnostic Too designed to assist in troubleshooting issues such as hangs, slow performance, memory leaks or fragmentation, and crashes in any user-mode process. The tool includes additional debugging scripts focused on Internet Information Services (IIS) applications, SharePoint, web data access components, COM+ and related Microsoft technologies.
ref: http://blogs.technet.com/b/stefan_gossner/archive/2011/07/18/finally-debugdiag-1-2-available-on-microsoft-download-center.aspx

3. _CrtSetDbgFlag() API from C Run-Time Library will display memory leaks in the Debug output window. 
ref: http://msdn.microsoft.com/en-us/library/e5ewb1h3(v=vs.80).aspx

4. Application Verifier tool can be used for identifying errors caused by heap corruption, incorrect handle and critical section usage. It may not work for a Application which is mix of UnManaged & Managed code.
ref: http://msdn.microsoft.com/en-us/library/ms220948.aspx


Other tools include Devpartner studio BoundsChecker, Rational Purify, SmartBear AQTimer, SoftwareVerify C++ Performance Validator ...

Performance Profiling:
Intel offers an array of application performance tools that are optimized to take advantage of the Intel® processors. You can employ these tools for developing the most efficient programs without having to write assembly code. These performance tools(Intel VTune Amplifier) will help you analyze your application and find and resolve the problem areas. The following sections summarize each of the recommended Intel® performance tools.
ref: http://www.ncsa.illinois.edu/UserInfo/Resources/Software/Intel/Compilers/9.0/main_cls/mergedProjects/optaps_cls/common/optaps_time_perf.htm

Developing Apps using HTML5

HTML5 is an umbrella term describing a set of HTML, CSS and JavaScript specifications designed to enable developers to build the next generation of Web sites and applications. What’s notable in that definition is its three parts: HTML, CSS and JavaScript. They define how developers use improved markup, richer style capabilities and new JavaScript APIs to make the most of new Web development features. 


ie, HTML5 = HTML + CSS + JavaScript

WebSockets:


The WebSocket specification defines an API establishing "socket" connections between a web browser and a server. In plain words: There is an persistent connection between the client and the server and both parties can start sending data at any time.

Defined in the Communications section of the HTML5 specification, HTML5 Web Sockets represents the next evolution of web communications - a full-duplex, bidirectional communications channel that operates through a single socket over the Web. HTML5 Web Sockets provides a true standard that you can use to build scalable, real-time web applications. In addition, since it provides a socket that is native to the browser, it eliminates many of the problems Comet solutions are prone to. Web Sockets removes the overhead and dramatically reduces complexity.


Adopting HTML5 in your Applications:


Adopting HTML5, rather than being a wholesale choice, is about making a technology-by technology evaluation and determining which technologies are right for your application. For each HTML5 technology you evaluate, look at (at least) the following factors when deciding whether that technology is ready for you to adopt:

1. How widely implemented across all major browsers is the technology?
2. How would you adopt this technology and “polyfill” support for browsers that don’t support a given feature?

The first factor is the most important, and when combined with an understanding of the browsers commonly used by visitors to your site, should give you a clear picture of which subset of the 100-plus specifications is worth evaluating further. That subset should consist of a set of stable specifications you can reliably adopt today for your users.

However, even with that stable set of HTML5 technologies, you shouldn’t ignore your users who haven’t moved to a newer browser. If you’re heavily involved in the day-to-day development for your site, you no doubt have some rough idea of the percentages of users visiting your site with a given browser. For most of us, it would be easy to look at the percentage of users visiting with an older browser and come to the conclusion that adopting any HTML5 technologies would negatively impact those users. Luckily there’s “polyfilling” to save us from waiting until some foggy date in the future to adopt HTML5.

Paul Irish (a developer on the jQuery and Modernizr projects) defines a polyfill as “… a shim that mimics a future API, providing fallback functionality to older browsers.” A polyfill is like spackle for your Web sites; it’s a way to determine if a given HTML5 feature is available to the user currently browsing your site, and to provide either a shim that “fills in” that support or a course of graceful degradation that enables your site to still function fully.

The most popular library associated with polyfilling is Modernizr, the JavaScript library I mentioned earlier. Modernizr provides some basic polyfills for semantic markup, feature detection for major HTML5 technologies and support for conditional CSS based on supported features. As noted, Modernizr will be the subject of an upcoming article; it will also feature prominently (along with many other polyfilling libraries) throughout this series. To learn more, download Modernizr at modernizr.com. 


Windows 8 Metro Style Apps:


Windows 8  Metro style apps have a brand new look and feel, run on a variety of devices, and you sell them on the Windows Store.Metro style apps can be developed using HTML5, Cascading Style Sheets, Level 3 (CSS3), and JavaScript.

Windows provides two sets of APIs for building Metro style apps: 

1. WinRT(Windows Runtime) 
2. Windows Library for JavaScript

Windows Runtime: These JavaScript, C#, Visual Basic, and C++ APIs provide access to all core platform features. The namespaces are exposed using API metadata format(Windows.winmd) similar to that used by the .NET framework (Ecma-335).

Windows Library for JavaScript: These JavaScript APIs provide controls, CSS styles, and helper functions that help you write object-oriented code. The WinJS namespace covers functionality that is similar to the Windows.UI.XAML namespaces in the Windows Runtime. When you reference these JavaScript files in your app, you must add base.js first, then ui.js

Metro style apps only: Windows Metro style app APIs that are expressed as HTML or XAML elements are supported only in Metro style apps, and are not supported in desktop apps or Metro style enabled desktop browsers.

ref:

Building HTML5 Applications - http://msdn.microsoft.com/en-us/magazine/ee532098.aspx?sdmr=Brandon%20Satrom&sdmi=authors


Creating Mobile Web Applications with HTML 5 - 
http://www.ibm.com/developerworks/xml/library/x-html5mobile1/index.html
http://www.ibm.com/developerworks/xml/library/x-html5mobile2/index.html
http://www.ibm.com/developerworks/xml/library/x-html5mobile3/index.html
http://www.ibm.com/developerworks/xml/library/x-html5mobile4/index.html
http://www.ibm.com/developerworks/xml/library/x-html5mobile5/index.html


Building Apps with HTML5: What You Need to Know - http://msdn.microsoft.com/en-us/magazine/hh335062.aspx

Creating Media Apps for Windows Phone - http://msdn.microsoft.com/en-us/magazine/hh975340.aspx

Develop HTML5 applications using Apache Cordova - http://msdn.microsoft.com/en-us/magazine/hh975345.aspx 


Why WebSockets - http://www.websocket.org/quantum.html


Modernizr: an open-source JavaScript library that helps you build the next generation of HTML5 and CSS3-powered websites - http://modernizr.com/

Microsoft ScriptJunikie Website for HTML5 sample code - http://msdn.microsoft.com/en-us/magazine/ee729207.aspx

Using HTML5 to Create Mobile Experiences - http://msdn.microsoft.com/en-us/magazine/hh975346.aspx

Developing an Advanced Windows Phone 7.5 App that Connects to the Cloud - http://msdn.microsoft.com/en-us/library/gg490765

Transforming a Android App into Windows Phone App - http://msdn.microsoft.com/en-us/magazine/hh965662.aspx

Develop Metro style apps using Visual Studio 2012 RC - http://msdn.microsoft.com/en-us/library/windows/apps/br211384.aspx

Apache Incubator -  http://en.wikipedia.org/wiki/Apache_Incubator