An AJAX developer has to deal with many details and low level interactions which are taken for granted by desktop developers as part of their environment. The following samples will highlight the differences. Could it be that with such a productive method, individual developers and small-to- medium developers can create complex AJAX applications which used to take significant expertise and a long time more quickly and without any prior experience and expertise?
Security is where the "Empty Client" really shines, and it is undoubtedly one of the most significant attributes of this model. By utilizing the "Empty Client" solution, all the serious security issues are eliminated because nothing except for UI commands and one static kernel is downloaded to the client. This means:. The following flow, which describes an "Empty Client" application, explains it in greater depth:. Flow Step 1 The first time the client approaches the server it downloads a small amount of kernel code which is constructed of:.
The kernel is sent in a compressed mode and weights about kb. Furthermore, it is cached on the client and on the server statically and will never change from this point forward. Security aspects: Only UI essential data is sent to the client, no applicative or sensitive data. Flow Step 3 Highly optimized events are sent to the server whenever a client performs a set of action that should result in executing server code.
Events metadata are constructed of UI object Id and the action performed. Security aspects: Events are reflecting UI behavior and never applicative logic which is uniquely handled by the server. Flow Step 4 The server executes the event handler and sends back highly optimized UI instructions to the client. The instructions are reflecting the deltas of changes between the last balanced state and the new state.
Security aspects: Server instructions are reflecting UI changes and presented data changes, however, will never contain hidden applicative logic or data which is uniquely kept and handled by the server. Flow Step 5 The client accepts the UI changes instructions and re-renders the parts which have changed according to the last server execution of logics. Security aspects: The client is responsible to render UI and that is the only aspect which is affected by application logics.
The server centric, event-driven design results in an enterprise-level security and very high level of fine-grained control over precisely what the user is seeing - all using one programming language - standard. The main safety benefit of the "Empty Client" model is that it will be impossible to hack a web application.
Instead of communicating at the component level in a scattered way it communicates the incremental updates, asynchronously through one central pipeline which it creates by design. What this means is that instead of opening scattered and numerous routes to the server, it channels all communication through its centrally controlled pipeline and that is the fundamental difference between traditional Ajax approaches to the Empty Client approach.
Despite its problems, AJAX is not the evil empire of technology. It is not necessarily doomed, and it will not necessarily doom us or lead us to search for alternatives. Over a million developers have joined DZone. Let's be friends:. DZone 's Guide to. Free Resource. Like 0. Join the DZone community and get the full member experience. Join For Free. How does the "Empty Client" approach work?
Are Enterprise AJAX Applications Doomed…Or Are We?
The benefits for developers and for enterprise level AJAX applications This model offers intrinsic benefits for enterprise applications since it provides additional measures of security and control which is not available on AJAX browser-based solutions. Examples of the new "Empty Client" approach practices versus traditional AJAX development Web developers are used to working with requests, responses, html and scripts as tools of the trade.
Events versus Requests and Response Events Although events were introduced into web environments, they did not match their desktop counterparts, which forced developers to add individual scripting client-side glue code. When AJAX was introduced, such concepts were reshuffled once again as most of the logic was transferred to the client. This forced the developer, yet again, to deal with the need to use requests and responses in order to implement his application. Desktop developers, on the other hand, were always given a fully event driven environment, making their development tasks much simpler.
Enterprise Ajax : Strategies for Building High Performance Web Applications | eBay
Programming a file explorer-like application was for them as simple as dragging a tree view and a list view and implementing a few event handling methods. This contrasts to web developers who have had to deal with exposing services and consuming them and, of course, doing everything using client-side scripting on the browser. Forms versus Pages Web developers are familiar with the concept of a page, which originates from the early days when such pages were static resources that had links to other pages.
The concept of a page is excellent when you are implementing a web site, but leads to a lot of work when you are creating applications. Take, for example, a dialog scenario, which is implemented over the web using two disconnected pages bound together through a client side script. Imagine that creating a dialog was as simple as creating an object, calling its methods, and setting its properties. This is exactly how desktop developers see dialogs.
This concept is called forms. A form represents a window which can have child forms, which are windows as well. It sounds outrageous that when you create a page it needs to have a script, which in turn opens a new browser window with a second page, which receives arguments and displays user interface, which then uses a script that is used to callback the parent page.
This is in comparison to the desktop developer who simply creates an object. When you are working in a single object oriented layer, you are also able to implement many useful design patterns, such as the observer design pattern. This means that when objects need to interact with each other they only need to post an event to the form and other objects will subscribe to that event saving you the hassle to explicitly bind events between controls.
Just to highlight the difference, the same task in the web scenario would require multiple cross referencing scripts. Form Designer versus Text Editor It is only natural that in a web environment, application design will take the form of a text editor. Originating from content authoring, web development environments require the flexibility of a text editor. The web development editor usually provides a mechanism for adding controls, while most of the layout is done via code.tejusragihoo.tk
Desktop environments, on the other hand, have always kept it simple. Their dedicated nature enabled them to provide very productive designers, allowing developers to really design their application with no need for hand coding whatsoever. Using concepts like anchoring and docking, they can lay out controls exactly how they want it. Programming a complex dialog, using desktop designers, is as easy as using a Power Point application. This provides desktop developers with the ability to rapidly develop and, if need be, change their dialogs.
Changing the layout, in web environments, usually requires a great deal of headaches to the web developers which are required to recode large tables to implement the new layout. Single Language vs. Multiple Languages Web developers must master many different languages in order to implement a web application. There are multiple server side pages, interacting with multiple script files and CSS files, which are required to work together as a well oiled machine. To spice up the web development task, it must also be done in multiple layers, which add a greater level of complexity.
It is common knowledge that the more application parts, the more work you must do to develop and maintain your application. Desktop developers, on the other hand, use a single compiled language to manipulate a well defined object model, which dramatically reduces the complexity of their applications. Using the explorer application scenario again, a WinForms implementation will include a single layered, compiled file. Developing the same application using WebForms will entail multiple files in multiple languages, with multiple layers. The complexity differences increase dramatically as the complexity of the application grows, presenting a glass ceiling for web developers that is reached very quickly.
Full OOP vs. The importance of these concepts for complex applications is crucial and the emergence of frameworks such as GWT and Script show that the big guys are aware of these issues as well.
What Can We at Centauruss Do for You?
These frameworks generate your scripts for you while allowing you to develop your application in a fully object oriented programming environment. On the other hand, desktop developers are provided not only with a full OOP environment, but also with lots of mature concepts that have been developed during many years of developing desktop applications. Design patterns originating from desktop development have, through the years, found their way to web implementations, but the architecture of web environments permits only partial implementations, leaving a great deal of useful design patterns exclusively to desktop developers.
Data Binding vs. Data Oriented Web developers are used to working in a stateless environment forced by the need to be scalable. But even when not implementing the next Amazon-like application, the same general purpose tools are still presented. It is common practice to implement stateful web applications as it dramatically simplifies implementation and reduces security issues.
- OpenAjax Hub and Mashup Assembly Applications.
- Frontiers of the Ottoman Imagination: Studies in Honour of Rhoads Murphey.
- EU Environmental Law and the Internal Market.
- Ignition Systems for Gasoline Engines: 3rd International Conference, November 3-4, 2016, Berlin, Germany.
However, working with pages still implies some kind of stateless implementation that presents developers with non-trivial tasks. Desktop developers, on the other hand, are provided with a stateful environment which utilizes the state to simplify development tasks. They are presented with a full object model allowing them to interact with the UI elements in a much more intuitive way. They are provided with a richer data binding mechanism which simplifies their development tasks.