Volta and GWT continues…… (II part)

The Volta features,

The most important aspect of any microsoft product is the familiarity, that what thy bank on the user-friendliness, that comes from the familiar usage of the keyboard keys, tools and techniques.Across all products it literally the same.

Same is the case of Volta too, but here the familiarity is the language, i.e the .Net languages, The Volta application is structured like a WinForms application, so is like bread n butter to most of the developers.

Similar to GWT , Volta also has extended support for creation of custom controls along with the basic set provided, which most of the developers developing custom controls in .Net windows and web applications.

Biggest change micrsoft have got into volta is that it the MSIL is recompiled to the target environment, In essence Volta is a recompiler. Volta works on MSIL rather than on a textual source language. Volta rewrites MSIL into any number of target languages, including, JavaScript and MSIL itself. This helps us to delay permanent decisions about architecture, target environment until after our code is basically working.so instead of worrying about the architecture the developer can concentrate more on the problem rather than the material things around.

(Following Excerpt From Microsoft labs website)

In summary, Volta confers flexibility in the architecture dimension through:

  • Language-independence. Write Volta code in any language that compiles into MSIL. For example, C#, VB, IronPython, etc.
  • Leverage the entire .NET toolchain. Use libraries; the IDE, Intellisense, auto-complete, snippets; FxCop; profiler; class browser; ILDASM; and so on.
  • Low entry barrier. Reduce your learning burden; use “only the languages in the room.”
  • Brown-field applicability. Volta-enable existing applications for the cloud.
  • Beyond 2 tiers. Refactor to as many tiers as you need using exactly the same mechanisms recursively applied.
  • Deep embedding of CLR semantics. Preserve exact CLR semantics across platforms.
  • Cross-browser support. Use one programming model across browsers.
  • Complete orthogonality with refactoring. Mix and match refactoring and retargeting.
  • Ajax-ready. Write Ajax patterns and idioms in familiar .NET languages.
  • Cross-browser support. Write the same code for Internet Explorer and Firefox.
  • Debugging transparency. Debug code with a specific browser.
  • Leverage browser-specific features. Where needed, access features unique to each browser.
  • Visual-Studio integration. Enjoy seamless integration with the IDE.

Pretty similar features to GWT .

Lets see in future which of them fare better, its again the fight of the open source and the proprietary software.

The Google Vs Microsoft fight can reap rich benefits for developer like you and me and also the world which is plugged in to the internet 24/7 😛

Thats it for today,till then bye and have a great day ahead.

– Deepak.

Microsoft versus Google Again…

ya trying to write my first blog……

Microsoft has come up with something called “Volta”… now whats Volta and why its versus Google.. the answer is its a kinda product placed against the toolkit by google i.e. Google Web Toolkit fairly known as the GWT.

I have just started to explore what these two product mean..the similarities the differences, may be i could note down a few here…i am not great at writing though 🙂

Lets start with what is Volta and what is GWT

The Volta technology is a “Experimental” toolset that help to expand the known and quite familiar .Net understanding and implementations in to multi-tier web applications.

It is like designing and building the complete Ship as a single structure using known tools and appliances then specializing the sections.

i.e building the app with the knopwn .net client app., then assign the portions of the application to run on the server and the client tiers or any other middle tiers as we move forward in the development process.

The compiler creates cross-browser JavaScript for the client tier, web services for the server tier, and communication, serialization, synchronization, security, and other boilerplate code to tie the tiers together.

Developers can target either web browsers or the CLR as clients and Volta handles the complexities of tier-splitting for you. Volta comprises tools such as end-to-end profiling to make architectural refactoring and optimization simple and quick. In effect, Volta offers a best-effort experience in multiple environments without any changes to the application.

The programmer can still debug and test the application, much as if it were still on the client-tier, because Volta’s tier-splitting is deeply integrated with Visual Studio 2008 and the .NET Framework 3.5. In summary, Volta extends the .NET platform to distributed software+services applications, by using existing and familiar libraries, languages, tools, and techniques. (excerpt from the microsoft labs volta overview)

Once again. Remember its an “experimental” developer toolSET (nbt toolkit :P)

Now whats GWT ..?? (Excerpt from the GWT Overview)

Google Web Toolkit (GWT) is an open source Java development framework that lets you escape the matrix of technologies that make writing AJAX applications so difficult and error prone. With GWT, you can develop and debug AJAX applications in the Java language using the Java development tools of your choice. When you deploy your application to production, the GWT compiler translates your Java application to browser-compliant JavaScript and HTML.

Here’s the GWT development cycle:

  1. Use your favorite Java IDE to write and debug an application in the Java language, using as many (or as few) GWT libraries as you find useful.
  2. Use GWT’s Java-to-JavaScript compiler to distill your application into a set of JavaScript and HTML files that you can serve with any web server.
  3. Confirm that your application works in each browser that you want to support, which usually takes no additional work

Few points what i could understand from the above overview (correct me if i am wrong)

i) Both targeting the huge arena called the World Wide Web.. i.e. the web technologies

ii) The buzzword “Cross-Browser” support with minimum fuss.

iii) Writing the code in much more of a known territory and then expanding over.

iv) Re-usablility of code, libraries, known patterns and techniques

Both the toolSET and toolKIT are in a very nascent stage.

The goal of these is to simplify the tasks (designing, building, deploying, testing, and debugging ) of a normal developer required for the distributed, multi-tier applications which are difficult to test and debug.

Makes life easier for developers as they don’t have to learn a NEW language , they can live with what they know fairly well i.e. Java or .Net and continue to grow in the extremely fast paced web development.This can help a great deal as the developer can focus on the core development rather than worrying about the New Language or a New technology.

——————————————————————————————-

Lets see how Volta Works

V olta first calls on the existing .NET language compilers to generate MSIL from source code . Then, based on declarative attribute annotations, Volta rewrites the generated MSIL and splits a single-tiered assembly to run across multiple tiers.

Based on the same declarative attributes and static code analysis, Volta optionally inserts instrumentation hooks into the code. This allows end-to-end, debugging, testing, performance profiling and security profiling of multi-tier web applications.

When no version of the CLR is available on the client, Volta may translate MSIL into semantically-equivalent Javascript code that can be executed in the browser. In effect, Volta offers a best-effort experience in the browser without any changes to the application.

And now how GWT works..?

The heart of GWT is a compiler that converts Java source into JavaScript, transforming your working Java application into an equivalent JavaScript application. Generally speaking,

  1. If your GWT application compiles and runs in Hosted Mode as you expect
  2. And GWT compiles your application into JavaScript output without complaint,
  3. Then your application will work the same way in a web browser as it did in hosted mode.

The GWT compiler supports the vast majority of the Java language itself. The GWT runtime library emulates a relevant subset of the Java runtime library.

Hosted mode In hosted mode, your application is run as Java bytecode within the Java Virtual Machine (JVM). You will typically spend most of your development time in hosted mode because running in the JVM means you can take advantage of Java’s debugging facilities and remain within an IDE like Eclipse.

Web mode – In web mode, your application is run as pure JavaScript and HTML, compiled from your original Java source code with the GWT Java-to-JavaScript compiler. When you deploy your GWT applications to production, you deploy this JavaScript and HTML to your web servers, so end users will only see the web mode version of your application.

Pretty similar huh?

A thing that stands out for GWT is its Completely Open Source.

All of the code for GWT is available under the Apache 2.0 license. If you are interested in contributing, please visit Making GWT Better.

I think enough of it for today, will be posting my understandings as i understand both of the techs.

The above blog is made up of two labs MS Labs and Google Labs

(content also copied from their sites posted below :P)

Enjoy reading from there too… me too reading from there 🙂

http://code.google.com/webtoolkit/overview.html

http://labs.live.com/volta/

Have a great day ahead.

– Deepak