You can check it out via his Ubiquity documentation example that shows you side by side documentation with the actual source code itself. This context is terrific. He does this all dynamically, and uses border padding to align the documentation with the code itself.

Here is what he has to say about how it is done:

The raw source code for the file being documented above just has chunks of comments that are marked-up in WikiCreole; when the parser runs into such a chunk, it renders it alongside the code it annotates using Ivan Fomichev and Chris Purcell’s JavaScript Creole 1.0 Parser.

The idea of using the documentation to annotate the code—or the code to annotate the documentation, depending on how you look at it—was inspired in part by some of the typography presented in Ellen Lupton’s excellent Thinking with Type, which I recommend to anyone interested in the field.

It’s nice not having a separate documentation build step: aside from making the process of writing and editing documentation quicker, it also lowers the barrier for entry to contributors since they don’t need to setup a toolchain. It also means that we get versioned documentation in every commit for free.

Right now there isn’t much else to the system; the only other feature I added is the auto-generation of quasimodal popup menus that link the names of XPCOM interfaces to their entries on XUL Planet and MDC. It’d be nice to have more features like this; other niceties would be an automatically-generated table of contents, JavaScript Doctests, search functionality, cross references to other code, and even the ability to fix code formatting errors in-page. For now, though, I need to focus on actually using this tool to document more code.

As soon as Ben and I saw this our minds started to race. What if you could navigate the code via hyperlinks too? Or have groups comment inline? Many exciting ideas.

It is fun to see the 80 character column limit in place (and seeing where that is ignored). 80 character limits with wide screen displays? I never get that :)

• Markup usage
• CSS and other presentation technology
• JavaScript, Ajax, and the DOM
• Flash, Silverlight and embedded content
• Backend systems

John and Scroll Magazine have a nice conclusion:

In this first of its kind study, over 1200 web professionals from across the globe, in a broad range of industry sectors and organization types, were surveyed on the browsers, operating systems, development technologies and practices they use when building web sites and applications.

Some surprising results from the survey include

• Nearly half the respondents use Mac OS X Leopard, and over half use a non Windows Operating system. Windows XP still outweighs Windows Vista among these users by a factor of 4 to 1 as their operating system of choice.
• Just a small majority, less than 5%, use any version of Internet Explorer as their primary browser, while Firefox dominates as the browser for choice, with over 60% market share. Safari 3 follows with 21%, and the much talked about Chrome on just 4%.
• Only a tiny handful use Internet Explorer 8 beta as their browser of choice.
• Despite the hype of the iPhone, less than 20% of respondents use the mobile web, and a similar number develop sites optimized for mobiles.

Web Development technologies

When it comes to web technology use, standards based and open source technologies dominate.

• Only 3% of respondents say they never validate their sites while 70% say that they frequently or always do.
• Only 10% of respondents say they use tables for layout, while well over 90% use CSS for styling their pages.
• 35% of respondents say they use microformats in their markup.
• 95% of respondents use JavaScript, and of these, almost all use libraries.
• JQuery is the dominant library used by some way, with 60% of respondents saying they use it.

With plug-in technologies, Flash continues to dominate, with a market share of around 60%. Silverlight still has a lot of work to do to catch the long time industry leader, with a bare 2%, little more than the Real format. Apple’s Quicktime has a surprising 20% of the market.
Java applets have all but disappeared from the toolset of these early adopter developers.

On the back end, open source accounts for the majority of technologies used. Among server operating systems Linux at nearly 60% is used more than twice as often as Windows at 28%, with Unix also well represented at 17%. Even Mac OS X, which is usually far down survey lists for server OSs, is used by 5.5% of respondents.
Apache at 70% is the dominant web server, with IIS at 23%.

Over 90% sites are database driven, with the open source MySQL at 70% and PostrgeSQL at 10% together accounting for the significant majority of sites by respondents. Microsoft’s SQL Server at 22% and Oracle at 9% were the other widely used database systems.

When it comes to server side programming languages, PHP is the most commonly used, at 63%, with JavaScript at 55%, ASP.NET at 17% and Python at 15%. Despite its flavor of the month status, Ruby comes in at 14%, with Java at 12%, indicating that the language which came to prominence with the rise of the web is well and truly being challenged from all sides when it comes to web back end development.

An often occuring UI pattern is “use the value of a textfield as hint what to input”. These fields all auto-clear when the user first focuses it (by clicking or tabbing it), and if nothing it entered, the hint will be shown once again once the user leaves it.

Because we decided to go this path for the “Quick entry” box we’re using for freckle time tracking, I dug out an older script I wrote and refreshed it a bit, and I present you defaultValueActsAsHint.

PLAIN TEXT

JAVASCRIPT:

1.  
2. $('element_id').defaultValueActsAsHint();
3.  

This is all there’s to it, and the file to include is merely 18 lines of code. It works with textareas, too. Just specify whatever should be displayed as hint in the value attribute of the input (or as text within the textarea tag) and off you go. Define a ‘hint’ style if you like to show the text in gray, italics or whatever you fancy.

Check out the test sample that lives in his prototype_helpers library that also includes deferUntil.

“The need is obvious for a cross-device mobile javascript library supporting iphone, palm, and android. blackberry browser still blows” -- Joe Hewitt

Joe of course created the popular iUI framework that mimics the native iPhone look and feel and gives you nice simple iPhone features via JavaScript.

Palm is on his list, because it is back in the game with their CES announcement of the Palm Pre, an offering that has an SDK that makes me happy. No Objective-C, no Java, just a Web stack!

Announcing Palm WebOS, Palm Mojo Application Framework, and Palm Mojo SDK

Palm WebOS, Palm's next generation operating system, integrates the power of a window-based operating system with the simplicity of a browser. The user experience is designed around multitasking, and makes it easy to run background applications, switch between applications in a single step, and handle interruptions and events without losing context. Using WebOS, you’ll be able to develop fast (and beautiful) applications.

The Palm Mojo Application Framework

Palm WebOS applications are easy to write using Mojo, a new application framework based on the HTML5, CSS, and JavaScript standards that web developers already know and love. WebOS applications are installed and run directly on the device at native speed and have access to a wide range of device services.

Mojo will enable you to:

• Build applications with gesture-based navigation, transitions, and scrolling
• Use the WebOS notification system to alert users without interrupting them
• Leverage the local storage capabilities of HTML5 so that data is available even when users are offline
• Use a JSON-based message bus to tap into a wide range of device services, including contacts, calendars, and location

And good news for Palm OS developers! There are a number of ways to migrate data from a an existing PDB file to your new WebOS app. Stay tuned for more information for developers with Palm OS applications who want to build WebOS applications.

The Palm Mojo SDK

Besides the Palm Mojo Application Framework, the SDK will include sample code, documentation, and development tools. An Eclipse-based IDE is included, and you will also be able to use your choice of tools to build WebOS applications. The Mojo SDK is currently in private prerelease, and will be available later this year as a free download from the Palm Developer Network.

The Palm App Catalog

Palm will provide an on-device application catalog to deliver your apps directly to users.

We are still some time out from the release, but very cool to see!

Clink Ecker of Ars has a nice piece where he talked to a developer familiar with the SDK. If anyone knows more, please let us know :)

Scott Robbin (Songza co-founder) has created a very cool jQuery plugin for pageSlide, an interaction based off of Aza's prototypes for Firefox Mobile and Ubiquity mouse gestures. The plugin wraps body content into a container and shifts it off of the page whenever a click event is fired, revealing a secondary interaction pane.

This plugin allows any developer to recreate a similar interaction on their own website using a few simple lines of Javascript. By attaching the method to an anchor tag, pageSlide wraps the original body content into a wrapper and creates an additional block for the secondary content load. The slide is animated whenever the click event is invoked.

PLAIN TEXT

HTML:

1.  
2. <script type="text/javascript">
3.     $(document).ready(function() {
4.         $('a.pageslide').pageSlide({
5.             width: "300px"
6.         });
7.     });
8. </script>
9.  

For some reason I enjoy thinking of my desktop as a virtual area that I can shift around.... so this can suite me well.

Release notes are here. As mentioned previously, this version will not be compatible with Firefox 3.1 (Shiretoko) and up. For that you’ll need a Firebug 1.4 alpha, soon to be dubbed beta available on getfirebug.com’s releases directory. Notes are on the releases page.

If I can babble a bit for a second, I’d like to say that I’m pretty proud of this release. Honza has made some fantastic improvements to the Net panel. John Barton has improved the Script panel and debugging features as well as tweaking the console. Maybe more significantly were some of the changes under the covers. The new Tracing panel (FBTrace) for debugging Firebug itself during development is a huge improvement over the previous console-based system. We’re starting to get some unittest coverage through John Resig’s and Honza’s FireUnit. And I think community involvement is at an all-time high with some excellent testing and bug reporting coming from all corners of the world. The message is getting out that Firebug is a great project to be involved in and that community contribution can really help move it forward.

So, thanks to everybody who helped out with this release. I think it’s the best Firebug yet.

The team seems to be gelling together and really doing some great work. I am looking forward to see more in 1.4 and above.

It is great to have new semantics for <section> and all, but what will browsers do with these new tags?

John walks through a simple example with the new tags, shows some issues, and then wonders if we could use the existing extension points (attributes):

Let’s invent a new attribute. I’ll call it “structure,” but the particular name isn’t important. We can use it like this:

<div structure="header">

Let’s see how our browsers fare with this.

Of course, all our browsers will style this element with CSS.

PLAIN TEXT

HTML:

1.  
2. div {color: red}
3.  

But how about this?

div[structure] {font-weight: bold}

In fact, almost all browsers, including IE7, style the div with an attribute of structure, even if there is no such thing as the structure attribute! Sadly, our luck runs out there, as IE6 does not. But we can use the attribute in HTML and have all existing browsers recognize it. We can even use CSS to style our HTML using the attribute in all modern browsers. And, if we want a workaround for older browsers, we can add a class value to the element for styling. Compare this with the HTML 5 solution, which adds new elements that cannot be styled in Internet Explorer 6 or 7 and you’ll see that this is definitely a more backward-compatible solution.

John then goes on to discuss the potential use of the role attribute, and more.

It feels like there are two issues here:

1. Are new tags the right way to provide new semantic value
2. Are there work arounds to back/forward compatibility.

Without compatibility, it will be impossible to get this off the ground for many people. What if we mix both worlds, and a shim is put in place to convert the new tags to divs and the like at runtime for browsers that don't support it. Is that enough?

You can get IE to support new tags as shown in this example by using document.createElement().

That is the vision that Daniel Glazman had when just created the HTML+CSS Templates Manifest 1.0 CC licensed spec.

You would end up with a file that looks like the example:

And, if you are into design, the OmniGraffle wireframe stencils have been updated!

The debugging exersize was fun, and he shares it with you on his personal blog.

The moral of the story is: watch out for that zoom feature in today's browsers!

Along the way, I got to learn that canvas supports fractional coordinates:

My first thought was that it would be due to fractional coordinates. I have years of experience with drawing APIs that force integer coordinates, so I’m used to relying whacking off the fractional part of a coordinate and making up the difference when necessary in a second pass. Canvas, on the other hand, supports fractional coordinates, which I’m told is the fancy thing to do these days. (How the fraction is converted to an actual pixel is depenendent on whatever drawing system is doing the heavy lifting somewhere down the stack.) When your coordinates are fractional, you can get this kind of fuzziness.

Because the interface I’m working with involves a few layers of rendering code, ensuring that integers ruled the roost took some time. But after quite a bit of poking around, I found no evidence of fractional coordinates. It was around this time I saw Vlad (Mozilla’s graphics guru) walking around the office and asked for some help.

We started looking for evidence of transforms that would introduce fractional coordinates–but ultimately came up empty handed. As we went through this process, he pointed out that the <canvas> context instances are reused, so it’s a really good idea to save() and restore() when obtaining a canvas to avoid polluting the context:

PLAIN TEXT

JAVASCRIPT:

1.  
2. var ctx = canvas.getContext("2d");
3. ctx.save();
4. // painting here
5. ctx.restore();
6.  

I had assumed each call produced a fresh, stateless context, so this was welcome news indeed.

But, user error was the true case:

And that’s when we noticed that I had zoomed in a click using Firefox 3’s fancy full page zoom feature. And that was causing the image the be scaled up, and the blurriness.

To show the latest, Ben got a demo working that decrypts Weave data in the client using a Worker:

What's changed?

1. The navigator object has been added to the worker scope. It contains the following strings that identify the browser, just as from normal script:
   • appName
   • appVersion
   • platform
   • userAgent
2. Workers can now be forcefully killed via the terminate function. Calling this function on a worker will immediately stop the worker’s execution.
3. Workers may only be created from a worker script that is hosted within the same origin as the parent page.
4. URIs for subworker scripts and imported scripts are now resolved relative to the parent worker script location instead of the owning page.
5. Error handling has been reworked according to recent spec changes. A worker script can now define an onerror handler that will be called with an error event with details about the exception. If the handler calls preventDefault on the event object then nothing else happens. If preventDefault is not called then the error event propagates to the parent scope’s (either a worker or the parent page) onerror handler.
6. Numbers, booleans, and even objects may be passed to postMessage in addition to strings. The only restriction is that objects may not contain functions or cyclical references (since we use JSON under the hood). This simplifies previous code that needed to use the JSON object to manually encode/decode the strings passed to postMessage.

Sébastein Gruhier has released a new address component that integrated a map with the address that you are filling. The UX is interesting as when you first get typing it doesn't really narrow down the address so you are seeing maps of bizarre places.

As well as a basic version, you can also tie in auto complete.

Features include:

• Javascript framework-agnostic. You can use it as is or with any great frameworks like Prototype, JQuery …
• Mapping system independent. The current implementation is based on Google Map using a Google Map proxy object.
• Interactive map display location while you arex typing an address.
• Center map on user location (based on its IP) if mapping system allows it.
• Fully customizable.
• Fully documented with pdoc.
• Works on Safari, Firefox, IE 6/7, Chrome and Opera.
• ...

I downloaded a trial version of iWork 2009 and published a Keynote presentation. The new Sharing function unfortunately requires you to configure and use the Apple Mail program, which I did before I could test out to see how the iWork.com shared documents work.

Looking at the JavaScript files, I see SproutCore and Prototype being pulled in, so everything is built with Ajax and web technologies. It's also using WebDAV to pull in the metadata about the document, which is interesting (though it's piping the WebDAV over some kind of proxy):

http://publish.iwork.com/iw/p159985190/.iWork/Share/Untitled.pages/Metadata/?webdav-method=PROPFIND

That URL returns an XML WebDAV document with the document metadata properties:

Notice how some of the metadata payload is JSON as well.

The web-based iWork apps are themselves built above SproutCore, using that framework to organize and do things. For example, there appears to be something named CoreHeckler that has to do with the commenting system, all built using SproutCore.

Using the Firebug Inspector, I see that the slides are a combination of an image file, the Canvas tag, and transparent DIVs that overlay; if there are hyperlinks on the page they are overlaid on a separate DIV that lies over the canvas. Comments also float on top of the Canvas using another DIV. The Canvas appears to be used for comments somehow, but I'm not sure how. I see CoreHeckler.Graphics being bound to the Canvas element; I'm not super familiar with SproutCore however.

Looking through the CSS I see they are using a few -webkit- specific CSS style rules, mostly around rounded border corners and shadows. They are also using the Webkit CSS Gradients and Clipping.

I wanted to see how things were handled in Internet Explorer. When I look at a published iWork.com document in Internet Explorer a very interesting dialog box first appears:

It was indeed slow; it took about 17 seconds to load the document in IE. Clicking on individual slides took about 4 to 5 seconds to show.

I used the Internet Explorer Developer Toolbar to get into the DOM and see how things run on IE. The first thing I see is that the Canvas tag is in the DOM:

However, notice a glitch that it has the <CANVAS> and </CANVAS> tags as separate elements, which can sometimes happen when IE is dealing with unknown tags. They are also definently using VML (Vector Markup Language) on IE, since I see them pulling in the VML behavior for IE on the main page. I wonder why they didn't just use the Google-ExCanvas library that emulates Canvas for Internet Explorer (Disclosure: I work for a team at Google that promotes open web technologies like this).

One other thing I noticed is that if you are on the iPhone you get redirected to an iPhone version of the app. This just replaces the URL /document/ section with /iphone/. When you navigate to this you get a PDF version of the page -- that must be the iPhone version, a PDF file!

I wanted to see how the Pages application does things as well, so I published a document there. The published text is selectable in the browser! The document itself appears to be an image file. To do selection, whenever I run over some text it appears that a Canvas element is created and a 'highlighted' type graphic is drawn over the correct characters. Internet Explorer also supports similar highlighting, though on there it appears to be using VML to do the highlighting.

All in all this is a very interesting web-based application built with Ajax and JavaScript!

The trick is easy: use the user_timeline to get the correct data back and provide it with a callback:

You can see the proof of concept here. The only problem with the code above is that if the user is not authenticated, Twitter's API will prompt an authentication dialog. You can work around this one by providing an extra parameter called "suppress_response_codes" which is meant to be used with apps that can only handle 200 response codes and don't allow for authentication (Flash apps for example):

This also means that you need to do your own error handling for cases where the user is not authenticated:

Now, this is pretty cool, but it also caused quite a stir on the twitter developer mailing list as it is a privacy concern. Using this technique I could simulate a user's homepage, fake an error, ask for re-authentication and phish their login data.

Whilst this is a problem, it is not really Twitter's fault - if anything then browsers and the lack of secure sandboxes are to blame. Some questions a proof of concept like this throws up are:

• Do we need something like "tweet this" buttons (as a call to action they can be very effective)?
• If we do, isn't it better to only show them when the user is a twitter user instead of cluttering the interface with all kind of buttons?
• Is a provider-unknown secret like Yahoo's sign in seal a step in the right direction (educating users instead of patching technology)?
• Is oAuth the answer?

SendMeHome lets you to assign a unique code, called a SendMeHome ID, to any physical item. We are launching our newest feature, Stories, which connects a group of people through an item as it travels the globe. Social networks such as Facebook mainly involve users communicating with their ‘friends’, SendMeHome is unique because it uses a real-world object to tell a story that enables interaction between new and like-minded people who may otherwise have never known of each other’s existence.

Our beta users have already created stories to write a collaborative novel, share cooking tips, discuss political events, and even transport a statue to Easter Island.

The site uses GWT components and integrates with services such as good ole Google Maps. You can check out a story. Having a code associated to items is a lot of fun (read: Webkinz) and seems to be something that can be useful.

* lightweight footprint
* no namespace pollution - everything is wrapped in obj.$QEvent
* normalizes the DOM event model
* work also with Javascript objects
* fixes common IE bugs including: all common used event properties, IE 2px bug http://ajaxian.com/archives/javascript-tip-cross-browser-cursor-positioning, fix many IE leaks, event handlers are FIFO executed
* prevents repeated registration of same type and listener
* 'this' in listeners references to object or element itself
* fixes window 'beforeunload' issue (doesn't work in Opera)
* fixes window 'unload' (must be removed by itself)
* fixes focus and blur events
* DOM events are more extendable: event keys, event objects ( event.myCustomFn() ), custom events
* firing events works for elements
* toggled and flashed events (removed after first fire)
* tested on (IE6-7, Firefox2/3, Safari, Opera, Chrome)

Isn't event sugar a solved problem? Daniel replies:

* Occasionally, I need a lightweight library that will work with other frameworks. Frameworks such as jQuery which don't extend the native prototype and therefor have no compatibility issues are not modular enough to meet my needs.
* No event implementation is perfect. So I took my own approach to the issue and created my dream package.
* This implementation could serve as a model for others.

The syntax is straight-forward:

Nicholas Zakas decided to dive deep on everyone's favorite sign that you've done something wrong:

Few web developers truly understand what triggers the long-running script dialog in various browsers, including myself. So I decided to sit down and figure out under what circumstances you’ll see this dialog. There are basically two different ways of determining that a script is long-running. First is by tracking how many statements have been executed and second is by timing how long the script takes to execute. Not surprisingly, the approach each browser takes is slightly different.

He finds that Internet Explorer's warning is based on total statements executed (5 million, and since it's Windows, you can change it via the Registry), Firefox and Safari time the actual script time (10 and 5 seconds, respectively), Chrome is a bit of a mystery, and Opera doesn't appear to have such a mechanism (and interestingly, appears to put its UI on a different thread than page rendering / script execution).

Regardless of the details, the lesson remains the same (again quoting from Nicholas' post):

Brendan Eich, creator of JavaScript, is quoted as saying, “[JavaScript] that executes in whole seconds is probably doing something wrong…” My personal threshold is actually much smaller: no script should take longer than 100ms to execute on any browser at any time. If it takes any longer than that, the processing must be split up into smaller chunks.

An interesting read!

Advanced Animation & Physics in JavaScript with Paul Bakaus

Forget about Web standards and go way beyond the usual capabilities of Web scripting languages. Learn how to create stunning effects using canvas/svg/vml, how to control animated graphics in JavaScript, and how to merge all kinds of standards and technologies to create a whole new world of possibilities. Using Paul's latest project as an example, he shows you how to adapt the things he talks about into new projects, featuring his new JavaScript game engine. Paul demonstrates how to control animated graphics in the browser, how to scale and rotate elements smoothly, and how to combine canvas, svg and filters with CSS to adapt new standards in browsers that don't support them. See how to move physics from the real world to the Web browser. In this session you learn how to: Create a walking animated character; Replicate new standards using existing technologies; Combine new standards to create a new experience.

Adv JavaScript: Closures, Prototypes, Demystified with Stoyan Stefanov

The times when JavaScript was just a toy language for making image rollovers and other, more irritating effects, are fortunately long gone. Today developers build much more sophisticated and complex applications be they for the Web (GMail), the desktop (Firefox extensions) or the server. JavaScript's prototypal nature makes its object-oriented features really different than "classical" languages like Java and C++, and we have to make sure we use the right tool the right way. In this talk you'll learn about JavaScript's most commonly misunderstood features and how you could put them to a good use.

Practical Functional JavaScript with Oliver Steele

This session covers how to use functional programming with JavaScript in real-life applications to implement client-side asynchronous processing, scheduling, and concurrency. These are complex areas that are difficult to think about or implement using straight object-oriented techniques, and become simpler with a handful of idioms that this talk demonstrates. Ajax developers (JavaScript or ActionScript) who are building applications that feature both ambient and reactive functionality, and that perform sophisticated tasks such as precompute display state or prefetch data, will benefit from this session. This session provides: A firmer understanding of closures and when to use them; Insight into implementing time-based and threadlike client-side behavior in the browser.

Applied JSON: HTTP REST, Ajax Databases & Beyond with Kris Zip

JSON has proven to be a very easy to use, yet immensely powerful data interchange protocol. However, by itself JSON lacks a number of important expressibility capabilities and efficient client/server data interaction must usually be customized. This session looks at how we can use various open specifications built on JSON to standardize and automate this interaction. We examine REST JSON, JSPON, and JSONPath. We also explore the capabilities of Ajax-accessible REST databases. The dynamic nature of non-relational databases can provide significant benefits for rapidly developing applications and providing JavaScript object persistence. Client-side code can directly participate in database interaction, simplifying the typical Web application stack. CouchDB, Persevere, and ActiveResource utilize a JSON REST interface. In this session, we learn how to interact with these simple interfaces and how to use JSONPath as a query language for JSON data stores. We see how these dynamic databases utilize JavaScript on the server for a consistent client/server JavaScript environment. We look at how Ajax databases affect security and provide an infrastructure for more secure Web applications. Finally, we cover JSON Referencing conventions as a mechanism for further expressing duplicate, circular, and cross-site referencing. Via a live demonstration, see how to use the Persevere open source tools to utilize these extensions to provide RESTful storage and server-side JavaScript. In this session you learn how to: Query JSON data with JSONPath; Use Persevere to provide a powerful persistence object store for JavaScript; Understand how JSON and the JSPON browser interacts with the Persevere object server; Employ JSON extensions and tools to enable open communication formats that can be used for rich and robust serialized object interaction between clients and servers with full object graph descriptiveness.

JSON SOA-based Client/Server App Dev with Kris Zip

JSON has proven to be a very easy to use, yet immensely powerful data interchange protocol. However, by itself JSON lacks a number of important expressibility capabilities and efficient client/server data interaction must usually be customized. This session looks at how we can use various open specifications built on JSON to standardize and
automate this interaction.
We examine REST JSON, JSPON, and JSONPath. We also explore the capabilities of Ajax-accessible REST databases. The dynamic nature of non-relational databases can
provide significant benefits for rapidly developing applications and providing JavaScript object persistence. Client-side code can directly participate in database interaction, simplifying the typical Web application stack. CouchDB, Persevere, and ActiveResource utilize a JSON REST interface. In this session, we learn how to interact with these simple interfaces and how to use JSONPath as a query language for JSON data stores.
We see how these dynamic databases utilize JavaScript on the server for a consistent client/server JavaScript environment. We look at how Ajax databases affect security and provide an infrastructure for more secure Web applications. Finally, we cover JSON Referencing conventions as a mechanism for further expressing duplicate, circular, and cross-site referencing. Via a live demonstration, see how to use the Persevere open source tools to utilize these extensions to provide RESTful storage and server-side JavaScript.
In this session you learn how to:
Query JSON data with JSONPath;
Use Persevere to provide a powerful persistence object store for JavaScript;
Understand how JSON and the JSPON browser interacts with the Persevere object server;
Employ JSON extensions and tools to enable open communication formats that can be used for rich and robust serialized object interaction between clients and servers with full object graph descriptiveness.

We're inviting all of the Java developers out there to an event organized by our sister site, TheServerSide.com, the Web's largest enterprise Java community. As a member of Ajaxian, you save an extra $100 off the registration fee with the code AJAXIAN. (Register before January 16 to save a total of $400 and get a free book!)

TheServerSide Java Symposium explores current and emerging trends in enterprise Java and how they apply to your daily work. Choose from over 45 technical sessions on new technologies, best practices and practical tips from some of the brightest minds in the industry, including Rod Johnson, Neal Ford, Scott Davis and 35 Java experts.

Tracks include Frameworks, Architecture, SOA, Language, Tools and Techniques.

Project and spec leads dive into:

• The latest features of Spring, JSF, Wicket, Tapestry, Google Web Toolkit and more frameworks.
• New Java language features, such as EJB 3.1, Glassfish and JavaFX
• Popular open source tools, including Eclipse, Maven, Lucene, soapUI, HtmlUnit for testing SOA, Ajax and RIAs.
• Expert recommendations on the use of Groovy, Scala and JRuby
• Building and maintaining a large-scale SOA
• How to create and consume RESTful Web Services.
• How and when to use an ESB.
• Best practices and tools for optimizing performance and scalability.
• And much more!

View TheServerSide Java Symposium agenda to see all of the sessions being presented.