Javascript Tutorials and Articles Directory
Javascript tutorials and articles: ajax, jquery, prototype, dojo, scriptaculous
A re-introduction to JavaScript
Why a re-introduction? Because JavaScript has a reasonable claim to being the world's most misunderstood programming language. While often derided as a toy, beneath its deceptive simplicity lie some powerful language features. 2005 has seen the launch of a number of high-profile JavaScript applications, showing that deeper knowledge of this technology is an important skill for any web developer.
Accessibility in Web 2.0 technology
Accessibility has become a hot topic as increased awareness and growing requirements demand that applications take into account the needs of all potential users. Accessibility covers not only the Web application, but document, desktop application and hardware, and so on. In the Web application domain, making static Web pages accessible is relatively easy. But for Web 2.0 technology, dynamic content and fancy visual effects can make accessibility testing very difficult. This article introduces the WAI-ARIA standard, which is designed to make future Asynchronous JavaScript and XML (Ajax) widgets accessible. The article also covers accessibility principles in Web 2.0 design and provides several code samples to get you started.
jQuery makes writing a good JavaScript-based Web application easy and straightforward, but there are a few extra steps required to turn your good Web application into a great Web app. This article details some of the steps to give your Web application the final layer of polish.
Ajax and Java development made simpler, Part 1: Generate JavaScript code dynamically with JSP tag
his first article in the four-part series presents a JSP-based technique for generating JavaScript code, significantly reducing the amount of code you have to write manually. The sample application shows how to generate JavaScript functions for sending Ajax requests and processing Ajax responses. You can use the simple techniques discussed here in a real application if you want to be able to change the Ajax code easily. The broader goal of this article is to demonstrate how to use JSP tag files to produce JavaScript code for any purpose, not just Ajax routines.
Ajax and Java development made simpler, Part 3: Build UI features based on DOM, JavaScript, and JSP
In this third part of the series, you'll learn how to develop client-side validators based on JavaScript as well as server-side validators, which are implemented as JSP tag files backing up their JavaScript counterparts. You'll also learn how to use resource-bundles that are reloaded automatically when changed, without requiring the restart of the application. Client-side validation is useful because it can reduce or even eliminate the cases when the form is returned to the user for correcting errors. Nevertheless, the JavaScript-based validation is not sufficient because it can be bypassed if the data is submitted to the server with a program or if JavaScript is disabled in the user's browser. This article shows how to implement both client-side and server-side validation.
Augmenting your HTML forms with Asynchronous JavaScript™ + XML (Ajax) callbacks to the server is a practical way to add Web 2.0 functionality to your application. Discover a variety of techniques to add Ajax code and enhance the user experience for PHP applications. When you think about Web 2.0 applications, often the most glamorous of them come to mind: the video of YouTube, the über-cool scrolling map of Google Maps, the geo-location functionality in Flikr. Often overlooked in such sites, however, is the humble HTML form that has undergone a big transformation with the popularization of Ajax technology. In this article, I show you how to use the Prototype.js JavaScript library to solve common user experience problems as you augment forms with Ajax code.
Ajax and XML: Ajax for lightboxes
It's possibly an urban legend, but I was told many years ago of a user interaction experiment in which USD100 (100 U.S. dollars) was taped beneath someone's seat while that person was using a desktop application on a computer. In the status bar of the application, it said, "There is $100 taped underneath your seat." The money was never found or claimed by any of the participants, which tells you just how poorly the status bar communicates information and how hard it is to get people's attention nowadays. This article shows several techniques that use a combination of PHP, Dynamic HTML (DHTML), and Asynchronous JavaScript + XML (Ajax) to throw content right into users' lines of sight so that it really grabs their attention.
Ask people which site is most representative of the new wave of applications on the Web, and most will answer YouTube. It's a site that has not only embraced new technology in a compelling way but changed how we view media and our relationship to it. Major stories can break on YouTube well before they appear on traditional media outlets, and when they don't, YouTube acts like one big TiVo for the world. Media sharing is changing the world, and from a technology standpoint, it's not hard to do. This article shows how to put an Ajax front end on a simple Web video-hosting application.
One strong suit of Asynchronous JavaScript™ + XML (Ajax) is presenting data from the server to users in a dynamic fashion. Discover several techniques that use Ajax for dynamic data display using tables, tabs, and gliders. When people think of Ajax and Web 2.0, they mostly remember the visual elements of the user experience. It's the feel of working in-place, without the page refresh, that gives Ajax its distinctive appeal. It's not completely hype: The page refresh of traditional HTML applications does cause a blink and a reload that even on the fastest connections presents a visual context change. In this article, I show several techniques—both with Ajax and without—that demonstrate this context change-free approach to user experience design. I start with the simplest example of Ajax user experience, the tabbed window.
Ajax and XML: Five common Ajax patterns
Asynchronous JavaScript + XML (Ajax) was certainly the technology buzzword of 2006 and looks to do just as well or better in 2007. But what does it really mean for your application? And which common architectural patterns are used widely in Ajax applications? Discover five common Ajax design patterns that you can use as a basis for your own work.
Web applications have entered a new era driven by web site goals such as fast response to user actions and user collaboration in creating and sharing web site content. The popular term attributed to these highly responsive and often collaborative sites is Web 2.0. This article is about the primary technique in use today for making Web 2.0 sites highly responsive: Asynchronous JavaScript and XML (AJAX).
Ajax for Java developers: Build dynamic Java applications
This article introduces a groundbreaking approach to creating dynamic Web application experiences. Ajax (Asynchronous JavaScript and XML) is a programming technique that lets you combine Java technologies, XML, and JavaScript for Java-based Web applications that break the page-reload paradigm
Ajax overhaul, Part 1: Retrofit existing sites with Ajax and jQuery
This first article in a series on overhauling existing sites with Asynchronous JavaScript + XML (Ajax) shows you how to eliminate pop-up windows and navigational dead-ends with simple modal windows.
Ajax overhaul, Part 2: Retrofit existing sites with jQuery, Ajax, tooltips, and lightboxes
This article walks you through the steps of retrofitting a Web 1.0 shopping site with Ajax techniques. You can download the before and after source code for the example application, and you can see both versions in action on the author's Web server. In addition to Ajax techniques and best practices, you will learn how Ajax can improve your user experience through principles of progressive enhancement.
Ajax overhaul, Part 4: Retrofit existing sites with jQuery and Ajax forms
In this installment, you learn to streamline complex processes by turning multipage forms into Ajax tabs. Your use case is the checkout path of your example shopping site. Without Ajax, multipage forms can seem long, painful, and off-putting to prospective customers. After an Ajax overhaul, even a complex checkout process can seem humane and approachable — as long as you're careful about how you structure the user interface. E-commerce sites aren't the only places that can benefit from these techniques. The same principles apply anywhere users must fill out a series of interrelated forms to complete a multistep process.
Learn how to build an Asynchronous JavaScript and XML (Ajax) Really Simple Syndication (RSS) reader, as well as a Web component that you can place on any Web site to look at the articles in the RSS feeds.
This article presents a technique that allows you to write lightweight test automation to verify the functionality of AJAX Web applications.
You've heard of it. It is the latest buzz term for web programmers these days. AJAX is an acronym that stands for Asynchronous JavaScript and XML. AJAX gains its popularity by allowing data on a page to be dynamically updated without having to make the browser reload the page. I will describe more about how AJAX works, and then go into some sample code to try out.
Ajax-based persistent object mapping
The Persevere persistent object framework brings persistent object mapping to the browser JavaScript environment. Object persistence has seen great popularity in the Java™ programming and Ruby worlds, and the dynamic JavaScript language is naturally well suited to mapping objects to persisted data. Persevere automates mapping and communication in Asynchronous JavaScript + XML (Ajax)-based Web applications in addition to simplifying much of the development challenge by providing a manageable data model, transparent client-server Ajax interchanges, automatic state change storage, and implicit transaction management.
Ajax-Powered Google Maps Mashup Tutorial
A new era of Web development is in full swing, and it is called Web 2.0. This has ushered in a new set of prototypical Web applications, including blogs, wikis, and mashups. Mashups are the focus of this tutorial, and you will see how a sample mashup can be built using a common set of technologies. This set includes JavaScript, Ajax, REST, JSON, and the Google Maps API. As a Web developer, it is important to understand how these tools fit together. In this tutorial I'll use these tools to easily build what is the ultimate Hello World mashup: a Google Maps mashup.
This article guides you through the AJAX basics and gives you two simple hands-on examples to get you started.
Web services are practically synonymous with XML, the payload format used for communicating between client and server. However, the application architecture imposed by the appearance of Ajax and REST techniques has forced many to contemplate alternatives like JavaScript Object Notation (JSON). JSON has come to the attention of Web service providers as a lighter and more friendly format for Web services clients in the form of a browser, or what would essentially be an Ajax-enabled application accessing RESTful Web services. This article addresses why JSON has gained traction in Web services design, including its main benefits and constraints as an alternative to XML. It also provides an in-depth look at how to easily produce JSON output in Java Web services, accompanied by a corresponding Web service client consuming JSON.
Android and iPhone browser wars, Part 2: Build a browser-based application for iPhone and Android
In Part 1, we introduce WebKit, the browser engine at the heart of the browser in iPhone and Android. In this article, we dig deeper by building a network management application that runs on both the iPhone and Android browsers. The application demonstrates browser-local SQL storage and Ajax, key technologies that enable a rich application experience from within the mobile browser. Additionally, the application leverages the popular jQuery JavaScript library.
Arrays and Control Structures in Object-Oriented JavaScript
In this article you will learn about the basics of Object-Oriented JavaScript which will cover the following: * Arrays * Flow control statements, such as loops and if-else conditions
Auto-save JSF forms with Ajax: Part 3 - Restore the user input of JSF forms
The first article of this series showed how to submit the user input of a Web form with Asynchronous JavaScript + XML (Ajax) and how to handle the Ajax requests with JavaServer Faces (JSF). The second article of the series discussed data management on the server side and presented a data repository for keeping the auto-saved form data. In this final installment of the three-part series, you'll find out how to restore the data of a JSF form, which is trickier than you might think. You will learn interesting JSF techniques, such as using the immediate and onclick attributes of JSF components, skipping some of the phases of the JSF request processing life cycle, and using hidden form elements to trigger JSF listeners. You will also learn how to include JSP/JSF expressions within the JavaScript code, how to use JavaScript with the HTML form elements generated by the renderers of the JSF components, and how to implement a servlet context listener for serializing and deserializing application beans.
Avoid unnecessary Ajax traffic with session state
Where possible, creating Web applications — including Ajax-based applications — in a RESTful way avoids a large class of bugs. However, a pitfall of REST (REpresentational State Transfer) is sending duplicate data across similar XMLHttpRequests. This tip shows how the moderate use of session cookies can maintain just enough server-side state to significantly reduce client-server traffic, while still allowing fallback to cookie-free operation.
Build a simple WYSIWYG Web page editor
Explore a simple Asynchronous JavaScript + XML (Ajax) system that lets your users assemble pages by adding and arranging pre-made widgets. Many sites provide this kind of functionality, but this easy-to-use system lets you do it on your own site and provides a simple library for creating new widgets.
Build a Twitter Web application
Learn how to create a Twitter-enabled Web 2.0-style application using Django, jQuery, and the python-twitter wrapper that you can easily use and plug in to your own Django project. With this application, you'll be able to see recent tweets, post updates, and show your friends and followers.
Build a Web presentation application using Ajax technology, Part 1: Developing the Web UI
How does Google Docs put such amazing functionality into a Web application? They leverage Web 2.0 technologies, which provide robust functionality with relatively simple code. In this article, learn how to build a Web application to create slideshow presentations using Asynchronous JavaScript and XML (Ajax) technology.
Build a Web presentation application with Ajax technology, Part 2: Make the presentation editable
Web 2.0 allows the development of robust functionality with a minimum of coding by reusing existing components rather than reinventing them. Part 1 of this series discussed using an Asynchronous JavaScript and XML (Ajax) framework to create a presentation application. Part 2 provides the framework discussed in the first article and adds functions to make it editable. Using this article, find out how much you can achieve with relatively little code.
Build Ajax applications using the first real Ajax server: Aptana Jaxer
Get acquainted with Jaxer, the first true Asynchronous JavaScript + XML (Ajax) server. Jaxer makes it possible to execute JavaScript code, Document Object Model (DOM), and HTML on the server side as well as giving you the ability to access server-side functions asynchronously from the client side. This article describes the features of Jaxer and shows the great potential that Jaxer has to offer, even in its infancy.
Build Ajax applications with Ext JS
Ext JS is a powerful JavaScript™ library that simplifies Asynchronous JavaScript + XML (Ajax) development through the use of reusable objects and widgets. This article introduces Ext JS, providing an overview of the object-oriented JavaScript design concepts behind it, and shows how to use the Ext JS framework for rich Internet application UI elements.
Build Ajax-based Web sites with PHP
Learn the process of writing Asynchronous JavaScript + XML (Ajax) applications using native JavaScript code and PHP. This article introduces a few different frameworks and application program interfaces (APIs) that reduce the amount of code you need to write to achieve a complete Ajax-based Web application.
Build an Ajax-enabled search page using the Rico JavaScript library, ColdFusion MX 7, and Windows In
A Web site or intranet has such a high volume of information available that you need special tools to index the content and provide access to it in a fast and convenient way. Learn how to do just that and provide a state-of-the-art search facility with the help of an Ajax library coupled with mature technologies like ColdFusion and Microsoft® Windows® Indexing Service.
Build Rich User Interfaces with jQuery
In this month's installment we build modal and modeless dialog boxes in jQuery and explain how to post data from them to the Web server.
Building Ajax-enabled auto-complete and cascading drop-down controls
Build Asynchronous JavaScript + XML (Ajax) controls that can be used in business-line applications. These configurable JSP TagLib-based controls leverage JavaScript Serialized Object Notation (JSON), JavaScript, and CSS. Because they are standard JSP TagLib controls, find out how you can easily drop them into any application to provide more intuitive and responsive user interfaces.
Building Ajax-enabled JSP TagLib controls, Part 2: Auto-populate and field validator controls
Two key technologies enable next-generation Web sites: Asynchronous JavaScript + XML (Ajax) and JavaScript Serialized Object Notation (JSON). Business-line applications can benefit from these technologies to provide more intuitive and responsive user interfaces. This article describes how to add Ajax and JSON to Java™ Platform Enterprise Edition (Java EE) Web applications by building reusable JavaServer Pages (JSP) TagLib controls based on Ajax. Within the article, I show how to build an auto-populate control that dynamically populates form fields based on the value entered in an HTML INPUT field. I also describe how to build an Ajax-enabled server validator control that validates a value of an HTML control by performing an asynchronous call to the server that validates the data. The server validator supports single-field validation, composite-field validation (First Name and Last Name), as well as multiple feedback mechanisms including Dynamic HTML (DHTML) and JavaScript alerts. You'll build the controls by integrating JSON, JavaScript, CSS, HTML, and Java EE technologies.
Building Ajax-enabled JSP TagLib controls, Part 3: Update panel and popup dialog box controls
Build Asynchronous JavaScript + XML (Ajax) controls that can be used in business-line applications. These configurable JavaServer Pages (JSP) TagLib-based controls leverage JavaScript Object Notation (JSON), JavaScript scripting language, and Cascading Style Sheets (CSS). Because they are standard JSP TagLib controls, find out how you can easily drop them into any application to provide more intuitive and responsive user interfaces.
Buttons, Menus, and Toolbars in Ext JS
The unsung heroes of every application are the simple things like buttons, menus, and toolbars. In this article by Shea Frederick, Steve 'Cutter' Blades, and Colin Ramsay, we will cover how to add these items to our applications. Our example will contain a few different types of buttons, both with and without menus. A button can simply be an icon, or text, or both. Toolbars also have some mechanical elements such as spacers and dividers that can help to organize the buttons on your toolbars items. We will also cover how to make these elements react to user interaction.
Combine JSF with Dojo widgets to create a better user experience
As a mature Web framework, JavaServer Faces (JSF) provides end-to-end lifecycle management and a rich component model with complete event handling and data binding. Dojo is a popular Asynchronous JavaScript + XML (Ajax) library that provides rich widgets and fancy effects for Web2.0 applications. By leveraging JSF and Dojo technologies, you can create a better user experience by using JSF integrated features on the server side and Dojo user interfaces on the client side. This article explains this process and describes how you can easily build Web applications to give your users a better experience.
Modern Web sites and Web applications tend to rely quite heavily on client-side JavaScript to provide rich interactivity, particularly through the advent of asynchronous HTTP requests that do not require page refreshes to return data or responses from a server-side script or database system. In this article, you will discover how JavaScript frameworks make it easier and faster to create highly interactive and responsive Web sites and Web applications.
With the growing popularity of Web 2.0, a new data interchange format called JavaScript Object Notation (JSON) is emerging as a useful way to represent data in the business logic running on browsers. Learn how PHP-based server programs can convert XML-formatted enterprise application data into JSON format before sending it to browser applications.
Craft Ajax applications using JSF with CSS and JavaScript, Part 2: Dynamic JSF forms
In the first article of this two-part series, author and Java™ developer Andrei Cioroianu showed how to use the style attributes of JavaServer Faces (JSF) components and how to set up default values for those attributes. In this second installment of the series, learn how to exercise the JavaScript-related attributes of standard JSF components. Learn several Web techniques based on the Document Object Model (DOM) APIs, JavaScript, and Cascading Style Sheets (CSS). See how to hide and display optional JSF components without refreshing a Web page, how to implement client-side validation that is executed in the Web browser, and how to develop a custom component that displays help messages for the input elements of a Web form.
Create a Java applet to download information in remote Web services
Start with a Java applet and build a server-based proxy system that uses your browser to access an arbitrary Web service. You'll use JavaScript code to access applet-based information and call a servlet, which retrieves the remote information. Thus, you bypass the same-server restrictions on what an applet can and cannot do.
Create Advanced Web Applications With Object-Oriented Techniques
This article discusses: * JavaScript as a prototype-based language * Object-oriented programming with JavaScript * Coding tricks with JavaScript * The future of JavaScript
Create an Ajax mindreader application with E4X and Prototype, Part 1
XML seems like a natural format for passing Ajax data. However, to work with XML in JavaScript using the Document Object Model (DOM) is not always the best way to handle this kind of data. This has given rise to other choices, such as JSON, which provide a more object-like feel for developers. Now ECMAScript for XML (E4X) combines many of the best features of the DOM with extremely easy data binding to provide a more straightforward way to deal with XML in the browser. In this two-part article series, you'll learn to use both E4X and the Prototype JavaScript library to create a simple Ajax mindreader application that plays Twenty Questions and learns about new objects as it goes along. Part 1 shows you how to create a system that takes an existing knowledge base and analyzes it to determine what the user may be thinking.
Create an Ajax mindreader application with E4X and Prototype, Part 2
In this article series, the sample application will be less sophisticated. Instead, you will implement a simple binary search, an algorithm that works on the theory that if you continue to eliminate as many non-suitable items in a set as possible that you'll eventually get to the one that you want. In fact, the name "twenty questions" stems from the theory that a set of everything in the universe can be narrowed down to just one item using about 20 different yes-or-no questions to narrow things down. In Part 2, you'll start to train the system for new items. If it guesses wrong, the system asks what the correct item was and how to distinguish it from the rest of the knowledge base. It then adds that item to the knowledge base and starts again. Finally, you'll integrate that functionality with an external database so that everybody benefits from what the system learns from others.
Create optimized Dojo builds for your custom Dojo artifacts
Create a custom Dojo build for your custom widgets without including any modules from the dojo/dojox/dijit packages into your build output. Custom Dojo builds reduce the number of modules to be downloaded by combining all the modules into a single file, thereby reducing the number of network calls required for the individual module files. These techniques were developed with a real-world project where compact packages were a requirement. This article helps you to create optimized Dojo builds using the Dojo build tool.
Create reusable and redistributable components with Dojo and AJAX
In this article, learn to use Dojo and Ajax to develop reusable components that can easily be integrated with core applications. A a step-by-step example shows how to develop a Web application that adds mailing capabilities to an existing blogging application, generates mailing widgets, and handles intricacies of cross domain communication.
Creating an Ajax Process Using PHP and Oracle
For some time now, Ajax (Asynchronous JavaScript and XML), has been all the rage in the Web development world. Coming to the forefront with some of Google's features (Suggest, Maps, Gmail, and so on), Ajax performs server requests without the user having to submit a form or click on a link. In other words, the Web browser can make the server request, and handle the response, without the user doing anything or even knowing that this is happening. The immediacy that Ajax brings is not only a great convenience, but it can also be downright cool. In this recipe, I discuss all the code necessary to use Ajax to go from a simple Web page to a JavaScript function to an XMLHttpRequest to a PHP script and, finally, to an Oracle database. Along with the code, I do talk about the individual pieces with respect to the whole picture: what each chunk does and why it's important. By reading this HowTo, you will acquire not only some sample code but also, hopefully, a broader understanding of the whole Ajax concept.
Creating mashups on the Google App Engine using Eclipse, Part 2: Building the Ajax mashup
n this article, the second of a three-part "Creating mashups on the Google App Engine using Eclipse" series, we will take the application we built in Part 1 and enhance it. We will improve its performance by using more data-modeling features of GAE. We will then take that performance even further by using GAE's Memcache services.
Creating modular interactive user interfaces with JavaScript
Discover a technique that lets you move sections of a Web page using drag-and-drop functions. Different aspects of the interactivity are implemented separately and then composed into a unified whole, allowing for flexible customization that can make your Web users very happy.
Creating sortable lists with PHP and AJAX
You might have been in a situation before where you had a list of items in your database that needed to be output in a specific order. These items could be anything: perhaps a listing of your favourite movies or your favourite books. For whatever reason, you want them ordered in a custom way that can’t be determined automatically (such as alphabetical). This article covers the implementation of a system that lets you easily define the order of such a list.
Crossing borders: JavaScript's language features
JavaScript is often ridiculed as the black sheep of programming languages. The development tools, a complicated and inconsistent document object model for HTML pages, and inconsistent implementation in browsers contributes to that sentiment. But JavaScript is much more than a toy. This article explores JavaScript's language features.
Data Tables and DataTables Plugin in jQuery 1.3 with PHP
In this article you will learn: * How to install and use the DataTables plugin * How to load data pages on request from the server * Searching and ordering the data
Debug and tune applications on the fly with Firebug
Why are your Web pages taking so long to load? Did you ever want to inspect or edit HTML while browsing? Tweak CSS instantly? In this article, learn to use Firebug, a free, open source extension for the Firefox browser that provides many useful developer features and tools. Using Firebug, you can monitor, edit, and debug live pages, including HTML, CSS, JavaScript code, and network traffic. Read on to learn how to speed up the tasks of debugging and tuning your Web and Ajax applications with Firebug
Develop a Dojo-based blog reader
The Atom protocol pair lets online providers of resources such as news, community Web sites, and blogs to syndicate their content through the Web. In a typical use of Atom, content providers syndicate a file, or a Web feed, and make it available over the Web. The feed, whose representation is defined in the Atom Syndication Format, provides a summary of recently added resources. Published feeds can then be used by Atom client software, such as blog readers, which leverage the Atom Publishing Protocol to discover newly added content and present it. This article will add to your Ajax knowledge by demonstrating how to start to develop an Ajax- and Atom-based blog reader (in this installment you will develop the view and controller components of the reader). You'll use the Dojo toolkit to develop the application, which will communicate with back-end Atom feeds using the Atom Publishing Protocol. You'll also use the Dojo storage package to keep feed subscription data.
Develop Ajax applications like the pros, Part 1: Using the Prototype JavaScript library
If you're developing Web applications these days, then you're doing Ajax development. Ajax is no longer something unusual that you add to your applications in special cases. It has become an integral part of Web development. To some, enhancing applications with Ajax used to be a tricky proposition. Cross-browser limitations to deal with, writing a lot of complicated JavaScript, and learning about magic numeric codes within that JavaScript were just a few of the challenges facing Ajax developers. Thankfully, several open source JavaScript libraries are available now to make things much easier. In this first article in a three-part series, you will create an Ajax application for managing songs using the Prototype JavaScript library and script.aculo.us.
Develop Ajax applications like the pros, Part 2: Using the Prototype JavaScript Framework and script
Are you building a Web application? Is it supposed to look more like cragislist or flickr? If the answer is the former, then you can probably skip this article. Still reading? Well you are in luck. In this article, Part 2 of a three-part series on JavaScript libraries, you will see how to use the Scriptaculous JavaScript library to enhance your Web applications.
Developing widgets with Dojo 1.x
The goal of this article is to give you the basics for developing HTML widgets using the Dojo JavaScript toolkit, starting from version 1.0. The article also describes several examples, beginning with simple widgets and moving up to more complex ones, while solving common issues you might encounter in widget development.
Dojo concepts for Java developers
If you're a Java programmer coming to Dojo with little or no experience of JavaScript, chances are you're going to struggle with some of the concepts that enable it to work. The main concerns with Dojo are that — at the time of writing — it is still in its infancy (version 1.0 was only released in February 2008) and the documentation available is still somewhat limited. This article helps you bridge the gap from Java code to Dojo so that you can get up to speed quickly and use the toolkit when developing your applications.
Dojo Grid using the MVC design pattern
Technologies are often linked together, and knowledge that you have in one area can help you gain skill in another. This article introduces the major features of Dojo Grid from an Model-View-Controller (MVC) design pattern perspective. Using the article, discover how you can understand and easily master Dojo Grid, even you haven't used it before.
Drag and Drop with ASP.NET AJAX
AJAX has revolutionized Web user interfaces, and ASP.NET AJAX has made AJAX available to the Visual Studio® users. It comes in three separate downloads: ASP.NET AJAX Extensions (asp.net/ajax/downloads), which provides the core, fully tested set of AJAX functionality; ASP.NET AJAX Futures (asp.net/downloads/futures), which contains experimental features on which the product group wants feedback; and the ASP.NET AJAX Control Toolkit (asp.net/ajax/ajaxcontroltoolkit/samples), which provides a grab bag of AJAX controls as well as an SDK for building controls of your own. Of the three, the Futures release has garnered the least attention from the developer community. That's unfortunate because, more than providing a glimpse into what future versions of ASP.NET AJAX might look like, the Futures Community Technology Preview (CTP) is chock full of features that can be used to build cutting-edge Web apps today. A case in point is drag-and-drop. Hidden away inside the Futures PreviewDragDrop.js file lies support for rich, browser-based drag-and-drop user interfaces. The model it uses is patterned after the old OLE drag-drop model, in which drag sources implement the IDragSource interface, drop targets implement the IDropTarget interface, and the system provides a drag-drop manager to connect drag sources to drop targets. The Futures drag-drop manager is an instance of a JavaScript class named Sys.Preview.UI._DragDropManager, which is automatically instantiated and made available through a global variable named Sys.Preview.UI.DragDropManager. For months now, I've been meaning to write a sample showing how to use PreviewDragDrop.js to implement real drag-drop, featuring custom drag sourcing and custom drop targeting. I finally got around to it, and the results are pretty cool. I learned quite a lot about DragDropManager in the process, including how to enhance it by adding support for custom drag visuals. Once you're familiar with the model (and comfortable with the concept of deriving classes and implementing interfaces in JavaScript), DragDropManager opens up a whole new world of possibilities for Web UIs.
Learn to use ECMAScript (aka JavaScript™) for XML (E4X), and discover the capabilities of the E4X enhancement, which was designed to facilitate simple and easy parsing, calculating, editing, and related activities on XML data.
Eliminating Postbacks: Setting Up jQuery On ASP.NET Web Forms and Managing Data On The Client
This article focus on getting jQuery and client-side data managmeent working with ASP.NET 2.0 without ASP.NET AJAX or ASP.NET MVC.
Enabling Data Exchange in Ajax Applications
In this article I’ll present the main methods for exchanging data between Ajax clients and servers, comparing the traditional Web application model with the Ajax model. I will also discuss techniques for handling and processing the data on both ends. First, you’ll learn how to encode the parameters of a request object on the client side, using JavaScript. You can use the so called URL encoding, which is the default encoding used by Web browsers, or you can include the request parameters in an XML document. The server will process the request and will return a response whose data must be encoded too. The article discusses JavaScript Object Notation (JSON) and XML, which are the main options for the response’s data format. Significant portions of the article’s content are dedicated to the XML-related APIs that you typically use in an Ajax application. On the client side, the XML API offer is very limited, but it is sufficient. In many cases XMLHttpRequest does everything you need, but you can also parse XML documents and serialize DOM trees in the Web browser, using JavaScript. On the server side, you have lots of APIs and frameworks that allow you to process XML documents. The article shows how to implement basic tasks, using some of the standard Java APIs for XML, which offer support for XML Schema, XPath, DOM, and many other useful standards.
Exceptional Performance : Best Practices for Speeding Up Your Web Site
This article discuss web site performance and propose 14 rules to improve it.
Explore multithreaded programming in XUL
As you create cross-platform desktop applications using XUL, you also can enhance your skills with JavaScript, CSS, and even HTML. XUL's cross-platform capabilities are not a collection of least common denominator features. Instead, XUL gives you the kind of power that you might expect from a desktop application toolkit, including access to native threads. You can even access native threads directly from JavaScript, writing code that executes in parallel. In this article, you will examine the multithreading capabilities of XUL, and create an application that uses multiple threads to retrieve data. You will take a classic IO-bound application, one that accesses multiple remote data sources over the Internet, and speed it up through multiple threads in XUL. The application will allow users to view and compare anonymous results of three popular search engines: Google, Yahoo, and Bing from Microsoft®.
Explore Rich Client Scripting With jQuery, Part 2
Achieving cross-browser compatibility for events is no easy task. The jQuery event handling API addresses the differences in event handling across browsers, allowing you to write more predictable JavaScript.
Finite state machines in JavaScript, Part 1: Design a widget
Finite state machines have long been used as an organizing principle for designing and implementing complex behavior in event-driven programs, such as network adapters and compilers. Now, programmable Web browsers have opened a new event-driven environment to a new generation of applications. Browser-based applications, popularized by Ajax, are becoming more complex. Designers and implementers can benefit from the discipline and structure that finite state machines offer. In this article, you, learn how to use a finite state machine to design complex behavior for a simple Web widget -- an animated tooltip that fades into and out of view.
Finite state machines in JavaScript, Part 2: Implement a widget
Part 1 of this series illustrated how to use a finite state machine to methodically design complex behavior for a simple Web widget -- an animated tooltip that fades into and out of view. In this article, you learn to implement that behavior in JavaScript and take full advantage of its distinctive language features, including associative arrays and function closures. The resulting code is compact and concise, its logic is transparent, and its animation performs smoothly even on heavily loaded processors.
Finite state machines in JavaScript, Part 3: Test the widget
In this series you learn to use how a finite state machine to methodically design complex behavior for a simple Web widget -- an animated tooltip that fades into and out of view. The resulting code is compact and concise, its logic is transparent, and its animation performs smoothly even on heavily loaded processors. In this article, learn how to deal with practical issues to make the implementation work in all popular Web browsers, and wrap things up.
You can learn a lot about how to do things correctly by understanding how things are done incorrectly. Certainly, there's a right way and a wrong way to write Asynchronous JavaScript™ + XML (Ajax) applications. This article discusses some common coding practices you will want to avoid.
The rise of JavaScript Object Notation (JSON) has gone hand-in-hand with the rise of Asynchronous JavaScript + XML (Ajax). JSON is useful because it enables you to easily transmit data that can be turned back into a JavaScript object, but it still requires custom scripting to deal with that object. JsonML is an extension of JSON that enables you to map XML data using JSON type markup, and this in turn enables you to easily create XML or XHTML data based on JSON markup and to build and exchange user interface (UI) elements. This article shows you how to make use of this handy tool.
GMaps4JSF integrates Google maps with JavaServer Faces (JSF), letting JSF users construct complex street view panoramas and maps with just few JSF tags. Hazem Saleh shows how to configure GMaps4JSF with Ajax4JSF and illustrates a weather application that uses GMaps4JSF with Ajax4JSF push component.
High-performance Ajax with Tomcat Advanced I/O
Using Non-Blocking I/O (NIO) improves server performance drastically because of its efficient use of system resources (threads). The gain in performance is noticeable in Asynchronous JavaScript + XML (Ajax) applications with long polling mechanisms. It also lets you control system-resource usage on a server under pressure. This article explains how to optimize your server for performance during the handling of both Ajax and regular requests.
How to document your Javascript code like the Java pros
If you're a Java programmer you already know how to document the right way. To comment your source code according to a standard and to generate an end user ready documentation with Javadoc™, saves a lot of time, keeps everything synchronized and is reliable. The good experiences with Javadoc have inspired a lot of people to create similar tools for their favorite programming language. In this article we have a deeper look at Javascript documentation.
Implementing simple AJAX interaction in your Web Application using XMLHttpRequest object
This example will give you an idea about how you can implement simple AJAX interaction in your web application.
Improve the performance of Web 2.0 applications
With the emergence and popularity of Web 2.0 applications, the way people use the Internet has slowly changed. These Web 2.0 applications now have many typical aspects, including having a rich client, a large page size, lots of small items on a page, excessive JavaScript coding, and so on. Most of these aspects, with the current Browser technology, can cause browser-side performance issues, especially in long-distance network situations. This article analyzes the key facts of typical Web 2.0 applications and describes how they will affect browser-side performance. It also takes a look at a very important part of browser-side performance -- browser-side cache.
In-place Editing using PHP and Script.aculo.us
In this article you will learn about editing the content in the page without moving, dragging, or dropping it. This feature is called in-place editing.
Inside the Microsoft AJAX Library
This article introduces the Microsoft AJAX Library and the JavaScript library for ASP.NET AJAX 1.0.
jQuery is a great JavaScript library, but what about its performance? Is the trade-off between ease of use and a performance hit on the Web page worth it? Is there even a performance hit at all? This article answers your jQuery performance questions and offers some tips to improve its performance in your own applications.
Internationalizing Web applications using Dojo
In this article, discover a way to perform native language support in the context of Web sites and Web applications using the i18n feature of the Dojo toolkit.
Introducing Multithreaded Programming to JavaScript
While increasingly more websites are utilizing AJAX, it is still difficult to develop complicated AJAX applications. This article explores how multithreading eases some of these issues.
Introduction to Ajax for Page Authors
Ajax has different implications for developers working in different roles. For example, component developers creating custom components for web applications build Ajax functionality into the design. Page authors use these Ajax components, along with widgets, JavaScript technology, and other techniques, to incorporate Ajax functionality into their web applications. Ajax impacts other roles too. For example, enterprise application developers need to add logic in server-side components to handle Ajax-related requests directed to the server. This article focuses on page authors and describes various techniques that you can use to add Ajax functionality to a web page.
Invoke dynamic languages dynamically, Part 1: Introducing the Java scripting API
You don't need to compile dynamic languages into Java™ bytecode to use them with a Java application. Dozens of scripting languages can be called at run time from Java code in a simple, unified way using the scripting package added to Java Platform, Standard Edition 6 (Java SE) and backward compatible with Java SE 5. Part 1 of this two-part article introduces the Java scripting API's features. It uses a simple Hello World application to show how Java code can execute scripting code and how scripts can in turn execute Java code.
Invoke dynamic languages dynamically, Part 2: Find, execute, and change scripts at run time
The Java scripting API added in Java SE 6 and backward compatibility with Java SE 5 allows dozens of scripting languages to be called at run time from a Java application in a simple, unified way. Part 1 of this two-part article introduces the API's basic features. Part 2 exposes more of its power, demonstrating how external scripts written in Ruby, Groovy, and JavaScript can be executed and altered at run time to change business logic without stopping and restarting the application.
JavaScript EE, Part 1: Run JavaScript files on the server side
Combine JavaScript with Java™ code on the server to get the freedom to use the same JavaScript routines on both servers and clients. In addition, the techniques presented throughout this series will allow you to maintain a single code base for both Ajax and non-Ajax clients. Because much of the server-side code would still be written in the Java language, you'll find it necessary to expose the Java Platform, Enterprise Edition (Java EE) features to JavaScript. In this series, learn how to run JavaScript files on the server side, call remote JavaScript functions with Ajax, and use the Java Scripting API with the JavaServer Pages (JSP) technology.
JavaScript EE, Part 2: Call remote JavaScript functions with Ajax
This article shows how to implement a Remote Procedure Call (RPC) mechanism for Web applications that use JavaScript on both servers and clients. You'll also learn several interesting techniques, such as implementing Java interfaces with JavaScript, building an XMLHttpRequest wrapper, making Ajax debugging easier, and using JSP tag files to generate JavaScript code.
JavaScript EE, Part 3: Use Java scripting API with JSP
In the previous two parts of this series, you've seen how to run JavaScript files on the server and how to call remote JavaScript functions with Ajax. This article explains how to use server-side JavaScript code with the Java™Server Pages (JSP) technology and how to build Asynchronous JavaScript and XML (Ajax) user interfaces that remain functional when JavaScript is disabled in the Web browser. The sample code consists of a small JSP tag library that you can reuse in your own applications as well as a dynamic Web form, which is generated with a piece of JavaScript code that can be executed on the Web server or in the Web browser.
Javascript Refactoring For Safer Faster Better AJAX
The amount of JavaScript code written by developers is continuously increasing, so is increasing it's impact on the overall quality of web applications. How can one quickly convert casual software development to professional software engineering? There may not be one simple answer here, but if your current JavaScript project is in trouble or if you are about to start a new one - this article is for you.
Javascript String Concatenation
Quick page loading and snappiness of a web site of a key factor to retaining visitors. Visitors do not like to wait! If you make visitors wait, they will go elsewhere. With raise of AJAX web applications it is quite tricky to make pages load fast. Many AJAX like application have to do lots of XML parsing and string manipulation to create the page in the browser. If not done carefully this can create an impression of web site being slow, even if server is lightning fast.
JavaScript Test Driven Development with JsUnit and JSMock
This article is a crash course in writing maintainable JavaScript. We'll add features to a running example by iteratively following a simple principle: write a unit test, make it pass. Each test will serve as a quality feedback loop, creating both a safety net and an executable form of documentation for anyone who wants to change the production code. By starting each feature with a simple failing test we ensure that all features are tested. We avoid the cost of rewriting code to test it later. This is particularly valuable given the fact that JavaScript developers have so much rope to hang themselves with - consider how much global mutable state there is between the DOM API and the language itself.
An introduction to the basics of JavaScript.
JQuery: Building tomorrow's Web apps today
JQuery is emerging as the JavaScript library of choice for developers looking to ease their creation of dynamic Rich Internet Applications. As browser-based applications continue to replace desktop applications, the use of these libraries will only continue to grow. Get to know jQuery in this series of articles that takes a look at JQuery and how you can implement it in your own Web application projects.
JSF 2 fu, Part 3: Event handling, JavaScript, and Ajax
Java™Server Faces (JSF) 2 Expert Group member David Geary wraps up his three-part series on JSF 2's new features. Find out how to use the framework's new event model and built-in support for Ajax to make your reusable components all the more powerful.
In the previous part of this article by Peter Svensson, we covered basic Dojo layout facts, ContentPane, container functions, DragPane, ExpandoPane, FloatingPane. In this part, we will focus on GridContainer, RadioGroup, RotatorContainer, ScrollPane, compound example using layout,and creating a widget.
Localized client-side validation messaging using Ajax
When building a Web application that caters to users across the globe, there are two points to consider: internationalized/localized page content and validation of user inputs and message displays. While you can easily build an internationalized version of the page using resource bundles (locale-specific property files) on the server side, it is very difficult to display internationalized validation messages when the validation is being done at the client side. Using Asynchronous JavaScript + XML (Ajax) is one option to make your life easier. This article discusses using Ajax and resource bundles together to make the process of internationalized and localized client-side validation messaging a little easier.
Make Ajax development easier with AjaxTags
Developers and users have much higher expectations for the usability and responsiveness of Web-based applications in the Web 2.0 era. Unless you've been living under a rock for the past two years, you've likely heard of Asynchronous JavaScript + XML (the Ajax technique). Ajax allows you to build slick, responsive, and highly dynamic browser-based user interfaces without requiring browser page reloads. This article takes a look at AjaxTags, a Java™/JavaScript Library that lets you easily integrate Ajax functionality into your JSP pages.
Manage tasks with common Ajax workspace
Want to increase productivity when managing tasks of developing Ajax applications? Regular developerWorks author Judith Myerson covers how you can use common Asynchronous JavaScript and XML (Ajax) workspace as a way to collaborate with team members, make or get workspace templates, allocate workspace dynamically, centralize communications for better administration, and make or get Ajax libraries. She shows you how to mitigate project risks to more acceptable levels and how to set up a pilot study on the workspace to test the application before integrating it into legacy enterprise systems.
Master-Detail Views with the ASP.NET Ajax Library
When you think of data-driven Web pages, most of the time what you really have in mind is a master-detail view of some cross-related data. Dino builds an example with ASP.NET AJAX 4 and jQuery.
Mastering Ajax, Part 1: Introduction to Ajax
Ajax, which consists of HTML, JavaScript™ technology, DHTML, and DOM, is an outstanding approach that helps you transform clunky Web interfaces into interactive Ajax applications. This article demonstrates how these technologies work together -- from an overview to a detailed look -- to make extremely efficient Web development an easy reality. He also unveils the central concepts of Ajax, including the XMLHttpRequest object
Migrating Web-Based PHP Applications to Ajax
This article describes a makeover of a typical database-backed web form. We'll show some old code – a mixture of HTML, JavaScript, and PHP – and rebuild it with modern web techniques like Ajax, and modern tools like jQuery.
Must-have tools for HTML, JavaScript and AJAX development and debugging
Use the best open source tools to work with Web pages, scripts, and styles, and make development of new sites and pages easy. Inspect and modify HTML markup, CSS, and JavaScript on the fly, inspect the DOM and client-server communications, and learn how bookmarklets can make development safer and easier.
OpenLaszlo -- A platform to rapidly build and deploy rich Internet applications
Meet OpenLaszlo, an open source platform, released under the Common Public License (CPL), for the development and delivery of rich Internet applications (RIAs). OpenLaszlo is based on LZX, which is an object-oriented language utilizing XML and JavaScript. Rich-client applications written with OpenLaszlo run across browsers and across platforms. In this article, we look at the architecture and APIs of OpenLaszlo with several examples. We also cover the basic debugging tools.
Patterns + GWT + Ajax = Usability!
The Google Web Toolkit (GWT) allows for easier development of complex Web sites. When combined with certain design patterns that enhance usability and Asynchronous JavaScript and XML (Ajax), these technologies and techniques provide a smoother look and feel to your application. The result is an application closer to a traditional desktop program than to a typical Web page.
PHP frameworks, Part 4: Ajax support
This series is designed for PHP developers who want to start using a framework, but have not examined the available frameworks in detail. This series examines why the three frameworks under examination were chosen, how to install each, and you'll get a good handle on the test application that you're going to extend in each framework. It might sound like a lot, but don't worry — we break it down into manageable chunks. Part 4 focuses primarily on Ajax support. The use of Ajax, using native code and third-party libraries, is examined — specifically, how each framework behaves and accepts specific popular libraries.
Preventing a Brute Force or Dictionary Attack: How to Keep the Brutes Away from Your Loot
A brute force attack, also known as a dictionary attack, is one of the more uncomplicated attacks available to a hacker. However, the odds of this type of attack succeeding can be very high if a site is not configured properly. Learn more about what can be done to defend a site against a brute force attack - including implementing incremental delays and carefully wording error messages - and which defensive strategies don't work.
Primitive Data Types, Variables, and Operators in Object-Oriented JavaScript
In this article you will learn about primitive data types, variables, and operators in Object-Oriented JavaScript.
Process XML in the browser using jQuery
The popular jQuery JavaScript library is best known for its use working with HTML, but you can also use it to process XML, if you're careful and aware of the pitfalls. This article shows how to use jQuery to process the Atom Web feed format. Web feed XML is perhaps the most pervasive XML format around, and the main fulfillment of the promise of XML on the Web. But most such formats use XML namespaces, which cause issues with many popular JavaScript libraries, including jQuery.
Real Web 2.0: Quick and dirty Web applications with bookmarklets
Web 2.0 is well known for the fact that it's not built on breathtaking new inventions, but rather on renewed emphasis on age-old Web technologies. One of those age-old technologies that is enjoying a revival in Web 2.0 is bookmarklets. A bookmarklet is essentially a Web application shoehorned into a regular browser bookmark. This article includes a fully functioning bookmarklet and installation instructions you can use to highlight text on any Web page.
ScriptManager Enables AJAX In Your Web Apps
As a server-side control, ScriptManager reacts to events in the ASP.NET page lifecycle and uses those events to coordinate the activities of all the controls, options, and code employed by ASP.NET AJAX. ScriptManager will hook a particular event, get notified when it occurs, and configure a few settings depending on the environment; this process will repeat itself several times through the rendering cycle of your ASP.NET page. The settings it configures, however, are often the exact settings needed to make your use of ASP.NET AJAX seamless. I will first go over a few of the main features of ASP.NET AJAX that the ScriptManager control enables for you, and then begin an exploration of the lifecycle of the control on the server. By understanding the internals of ScriptManager, you will gain a deeper appreciation for the options it provides for Web application development and learn how to get the most out of it.
Seamless JSF, Part 3: Ajax for JSF
JSF's component-based methodology encourages abstraction, but most Ajax implementations interfere with it by exposing the underlying HTTP exchange. In this final article in the Seamless JSF series, Dan Allen shows you how to use the Seam Remoting API and Ajax4jsf components to communicate with managed beans on the server as if they were local to the browser. You'll learn how surprisingly easy it is to leverage Ajax as a natural improvement on JSF's event-driven architecture and how to do so without compromising the JSF component model.
Simplify Ajax development with jQuery
jQuery is a JavaScript library that helps simplify your JavaScript™ and Asynchronous JavaScript + XML (Ajax) programming. Unlike similar JavaScript libraries, jQuery has a unique philosophy that allows you to express common complex code succinctly. Learn about the jQuery philosophy, discover its features and functions, perform some common Ajax tasks, and find out how to extend jQuery with plug-ins.
Take a legacy path to advanced GWT controls
The Google Web Toolkit (GWT) provides libraries and tools that let you develop Ajax applications in the Java™ programming language. Unfortunately, GWT's standard gallery of UI controls (widgets) doesn't provide the advanced features that modern enterprise applications require. This article shows a technique that addresses this deficiency. Find out how to give GWT controls advanced functionality with relatively simple coding by integrating a popular JavaScript grid component with a GWT application.
The Abstract User Interface Markup Language Web Toolkit: An AUIML renderer for JavaScript and Dojo
Get an overview of the Abstract User Interface Markup Language (AUIML) Web Toolkit (AWT). Learn how the AWT makes it possible to develop Web 2.0 interfaces quickly and easily by merging the ease-of-use and expressiveness of the AUIML visual designer with the versatility of the Dojo toolkit. Rapid development of user interfaces is made possible thanks to the AUIML visual editor and also because of the availability of a number of ready-to-use patterns. Experience has shown that the combination of these two factors provide a significant increase in productivity, and this is even more true considering the fact that, currently, there is no comparable technology that targets a Dojo interface.
Unit testing Web 2.0 applications using the Dojo Objective Harness
Unit testing is an important part of quality software development, particularly in the agile and extreme programming development methodology. Traditionally, automated unit testing of Web 2.0 client-side user interfaces was difficult and often not attempted. However, Dojo provides a unit testing harness that lets you evaluate both JavaScript functionality and the visualization of the user interface. This results in a thoroughly tested user interface that will ultimately contain significantly fewer bugs. This article demonstrates the main features of the Dojo Objective Harness (DOH) and describes its superior capabilities compared with other test harnesses for Web 2.0 applications.
Use jQuery and PHP to build an Ajax-driven Web page
Learn to use jQuery, the lightweight JavaScript framework, to add Asynchronous JavaScript + XML (Ajax) functionality to your PHP pages.
Use XForms and Ajax to create an autosuggest form field
Web application development has been revolutionized by Ajax. What was once a new and flashy technology is now becoming ubiquitous. End users are coming to expect that certain interactions with a Web application will be done "with no refresh," in other words, using Ajax. The ubiquity of Ajax for users has not yet translated to client-side technologies. There are many Ajax frameworks out there that make it simpler to use Ajax, hiding some of the cross-browser issues, but building an Ajax-enabled Web application is still a non-trivial task, to say the least. XForms is a standardized technology that offers many benefits that are complimentary to Ajax. In this article you will see some of the benefits of using Ajax and XForms together by implementing an autosuggest field.
Using Ajax for Web Application Development: What Businesses Need to Know
Ajax is a hot topic today when it comes to web application development projects. Because it's become such a buzzword, businesses may be wondering how they can incorporate this form of web programming into their websites and what the benefits could be. This article will help you understand the origins of Ajax as well as the pros and cons of its use.
One of the classic drawbacks to building a web application interface is that once a page has been downloaded to the client, the connection to the server is severed. Any attempt at a dynamic interface involves a full roundtrip of the whole page back to the server for a rebuild--a process which tends to make your web app feel inelegant and unresponsive. In this article, I'll be exploring how this problem can be tackled with the use of JavaScript and the XMLHttpRequest object.
Web Application Request-Response Testing with JavaScript
This article explains how to write simple and effective browser-based request-response test automation using JavaScript.
This article aims to accomplish two major things: giving an introduction to the Dojo JavaScript Framework and a walk-through of how to approach creating a RIA using dynamic HTML and Dojo.
Working with jQuery, Part 1: Bringing desktop applications to the browser
jQuery is emerging as the JavaScript library of choice for developers looking to ease their creation of dynamic Rich Internet Applications. As browser-based applications continue to replace desktop applications, the use of these libraries will only continue to grow. Get to know jQuery in this series of articles and learn how you can implement it in your own Web application projects.
Working with jQuery, Part 1: Intermediate JQuery: Using plug
The popularity of jQuery owes a lot to its decision to include a plug-in architecture. This decision allows any number of third-party developers to create and extend the jQuery functions beyond the original library functions. The result is hundreds of plug-ins that provide nearly any type of function needed on a Web application. This article describes this plug-in architecture and explains how jQuery can help your Web application behave just like a desktop application.
Working with jQuery, Part 2: Building tomorrow's Web applications today
This second article in the jQuery series looks at how to add more interaction to any Web site to create a dynamic Rich Internet Application. Learn how jQuery utilizes a combination of events produced by user interaction, information gathered from the Web site itself, and the ability to change the look and feel of the application without reloading to create these RIAs quickly and easily.
Working with jQuery, Part 2: Intermediate JQuery: The UI project
The jQuery UI package aims to create a well-defined and reliable set of user interface widgets that you can reuse within your own Web applications. The goal is to provide well-tested widgets that go beyond those available in HTML Input elements, and ease the work of all user interface developers.
Working with jQuery, Part 3: Intermediate JQuery: Creating your own plug-in
his article focuses on how you can give something back to this great community, by writing your own plug-in and checking it into the plug-in pages hosted by jQuery.
Writing a custom Dojo application
Learn the tips, techniques, and pitfalls when developing Web 2.0 and Dojo applications. Wendi Nusbickel and Melissa Betancourt have worked on the Dojo application documented in this article for over a year. Having recently completed the development of a Web 2.0 Dojo prototype, they share the experience they gained when creating a custom Dojo application.
Your First Cup of Web 2.0 - A Quick Look at jQuery, Spring MVC, and XStream/Jettison
This article shows how existing web pages can be tweaked to request data via AJAX, by using jQuery, a JavaScript library, which involves minimal changes to existing code.