Weblogs: Javascript Links

• Sniff my browser: The Modernizr inadequacy -- Tim documents why Modernizr isn't a good tool for progressively enhancing CSS, and why because of these side-effects it is failing to be a useful detector of JavaScript features.

• The problem with SproutCore -- Esteemed colleague Steve Webster notes: 'SproutCore doesn't just ignore progressive enhancement — it hacks it into tiny little pieces, urinates all over them and then mails them back to you one by one.'

• JSON creator slams Ajax, Web -- Douglas Crockford uses a keynote to rant about the state of Ajax. Excellent points and realistic: '[JavaScript is a] deeply flawed language, with an unpopular programming model. But to its credit, it's working really, really well in an environment where Java failed'

• Review: The Book of JavaScript, 2nd Edition: A Practical Guide to Interactive Web Pages -- Chris Heilmann reviews a recent 2nd edition of Thau's popular Book of JavaScript, and finds a book that hasn't taken into account the rapid evolution of JavaScript, particularly unobtrusive scripting and progressive enhancement. Its as if the web standards movement never happened, and we're still back to the bad old days of browser-dependent scripting.

• The essentials of DOM scripting in 10 minutes -- Chris Heilmann cleverly demonstrates DOM in this screencast, using a piece of markup and showing the effects of various DOM incantations. Its a practical overview, and packs in a lot of detail in 10 minutes.

• Netvibes: A Lesson in How to Build an Insecure Widgets Platform -- Dare explains some of the insecurities of Netvibes' handling of third party widgets, and how it opens up security holes. Dare offers suggestions on closing those holes. A practical explanation.

• Learning JavaScript -- Co-worker Tim presents his list of must have JavaScript reference material, covering recent JavaScript books, freely available Douglas Crockford online videos, and reference websites. Its a good overview of the material out there. I've been fortunate to see Douglas' presentations in person - the content is excellent, and really clarified concepts like closures and prototypical inheritance.

• Ajax Debugging with Firebug -- Joe Hewitt, in this Dr Dobbs article talks about using the Firebug extensions to inspect and debug Ajax applications (or any browser-based JavaScript application). It also has CSS inspecting capabilities, editing JavaScript on the fly, inspecting HTTP request and responses, logging, breakpoint debugging and profiling. A useful howto.

• Event-Driven Web Application Design -- Christian Heilmann outlines a core technique for building web applications - designing it around the use of events. This allows the code to be more modular and more maintainable. Chris bridges the divide between web standards based approach to development, and the framework-based approach to development. Its a key concept to building complex interactions in web applications.

• Dear JavaScript Library Developers -- Its cool these days to write your own JavaScript library, but don't forget about the developers that want to use your library. This is Chris' wishlist to lessen the painful barrier of adopting or switching libraries. The key is good documentation and a dose of realism.

• JSON -- Douglas Crockford reminisces about how JSON came about, and the history of its naming. Now its a globally recognised standards, displacing XML in a number of web services applications.

• Bonzai menu -- Christian Heilmann does a tree menu without using loops. It demonstrates the flexibility and power of Event delegation - catching events at a higher level in the document. It drastically cuts down on the number of events you need to add to a document. One event handler per menu, rather than one per link in the menu.

• Event Delegation versus Event Handling -- Christian Heilmann presents some working code examples and an explanation over Event Delegation. Its the difference between assigning the same event handler to hundreds of links versus assigning the event handler to one parent node.

• Douglas Crockford: ++ -- The ++ operators of C-style languages are useful, but can lead to usage that's difficult or harder for humans to interpret. The main element of a good programming style is that code must be readable by humans - that means the code does what it looks like its doing. One of the problems with ++ are the side effects when used in expressions - avoiding that usage makes code easier to understand.

• Adobe Flex 2 Language Reference -- A Javadocs-like ActionScript reference for Adobe's Flex 2 language platform. Its ActionScript 3.0 which is based on EcmaScript 4.0. The MXML elements are codified as pure ActionScript objects in the mx.* packages.

• Text-Resize Detection -- A custom event that fires when a font-resize is detected. An ingenious idea that opens up a whole host of JavaScript accessibility-related features. (Disclaimer: I'm a web developer at Yahoo! Europe, sitting alongside the clever web developers who created and refined this technique).

• JSON All The Way -- JSON is proving to be one of the most practical options to delivering semi-structured content on the Web. As Drew notes: 'if you want people to hack on your APIs, roll out JSON support.'. Just from experience, when using a data source you trust, its much quicker setting up a JSON transaction than the XML equivalent.

• Avoid Common Pitfalls in Greasemonkey -- Mark Pilgrim dissects the security issues of the 0.3 Greasemonkey, and describes how the new architecture of Greasemonkey works, pointing out pitfalls and how to address them. Excellent resource (via dive into greasemonkey)

• Dive Into Greasemonkey -- Mark Pilgrim's essential online book about developing Greasemonkey scripts. Excellent starting point for Greasemonkey developers. (Its a prelude to O'Reilly's Greasemonkey hacks, also by Pilgrim).

• Greasemonkey: Writing User Scripts -- GreaseMonkey scripts trigger off before the window.onload event, so adding other events needs to wait until window.onload. Amongst the other useful information offered.

• JSON and the Dynamic Script Tag: Easy, XML-less Web Services for JavaScript -- Webservices using the script element, JSON data structure and a callback function. Perhaps the simplest way of using web services from a JavaScript enabled page. The main requirement from the server is returning a JSON structure wrapped inside a callback.

• Web Services + JSON = Dump Your Proxy -- Calling JSON web services using the script element bypasses the default security model - so no back-to-original host proxy script is needed. Very clever, and useful.

• Wikipedia: DOM Events -- Tables of events from typical mouse and form events, through to DOM mutation events, Microsoft-specific events, and XUL events. (via Think Vitamin and Dustin Diaz)

• 15 things you can do with Yahoo! UI -- Collection of interesting pointers and demo of library effects from Dustin Diaz. The DOM Mutation events caught my eye - a selection of useful looking events worth adding listeners to, including DOMNodeInserted.

• RFC 4627: application/json -- JSON has its own mime-type ratified, and now its own RFC number.

• Enumerating JavaScript Objects -- Dean Edwards unleashes the forEach function, catering both for Mozilla's new forEach function and dealing with the finicy problems of iterating over Arrays. Superb!

• Dynamic Content with DOM-2 -- A good overview of manipulating a DOM object with standard DOM methods (as well as the de-facto innerHTML). (via Gez)

• JavaScript and Namespaces -- Dan Webb doesn't like Yahoo! YUI long namespaces. Dustin Diaz and Dean Edwards continue the conversation in the comments. Dean: 'As a rule of thumb, if you need more than three dots to access a method then you have too much namespacing going on.'. Lets not reimplement java package naming conventions.

• Publishing Custom Events in JavaScript -- Dustin introduces the concepts behind custom events and shows step-by-step how to define and initiate your own events using the Yahoo! JavaScript library. Its a clever way of abstracting events in your JavaScript applications. The ability for later code to register itself as a listener creates an extensible applications.

• Global Domination -- Douglas Crockford talks about the evilness of global variables and about using a root namespace to avoid collisions when JavaScript libraries and functions are mashed-up. Another facet of responsible and mature use of JavaScript.

• PPK on JavaScript -- More dead-tree JavaScript goodness, this time courtesy of Peter-Paul Koch. For people with some JavaScript experience wanting to learn more. Another DOM Scripting Task Force member gets into print - now there's a decent selection of books about the responsible use of JavaScript. Congrats PPK!

• June 6th Is JavaScript 'Array' and 'Object.prototype' Awareness Day -- Woot. D-day for JavaScript. There's a ton of good stuff covered and linked to in this piece. (via Simon Willison)

• Core JavaScript 1.5 Reference -- The ex-Netscape manual on Core JavaScript is still alive at Mozilla. A very useful reference to JavaScript 1.5

• Namespacing your JavaScript -- Dustin Diaz uses the object literal way of writing code to namespace his functions. Nothing about namespacing classes, though.

• Javascript, the DOM and application/xhtml -- 'when dealing with XML documents Gecko needs you to use document.createElementNS in place of document.createElement when manipulating the DOM.'

• What is OpenLaszlo, and what's it good for? -- Flash based web applications. Built around XML and JavaScript. Pointers to PHP-based servers. I like the look of Lazlo Mail. This will give XUL a strong run for its money.

• easytoggle and debugging in Safari -- Simon Willison on how to use the JavaScript console in Safari. You need to open up the console to see the messages. (Console is an output only window, not to be confused with the Terminal which is the shell).

• Enable the Safari debug menu -- From Safari 1.3, a Terminal command enables a debug menu containing some very useful JavaScript debugging tools - from a DOM and Render Trees, through to the very useful JavaScript console.

• Using JSON (JavaScript Object Notation) with Yahoo! Web Services -- Handling JSON responses from Yahoo Web services. The callback function reference is extremely elegant.

• How to build a Maps Mash-up -- By Dan Theurer - using Yahoo Maps API. Looks very elegant. The core of Yahoo Maps is essentially a JavaScript file that handles the rendering of the map and the user-interaction. There's also a handy function for adding HTML flavoured markers to the map.

• Google Web Toolkit -- A Java framework for writing AJAX applications. Includes a browser history management so not breaking the back button. The HTML is quite old-school - which is a great pity.

• AJAX, Accessibility & Screen Readers -- Ian Lloyd on brothercake's AJAX and screen readers articles. Accessible AJAX has a number of problems. The main issue is notifying screen readers of a change in the DOM.

• Joe Clark: Iceweb 2006 speaker notes -- Joe does a talk about accessible AJAX. He tests Basecamp, and the results are surprising. Basecamp does work in screenreaders, but there are some problems that need to be overcome.

• BadgerFish: Translating XML to JSON -- Very interesting concept, and probably useful for a DOM Scripter's toolbox. The examples show some intelligent namespace handling.

• Externally Declared Global Variable Leak -- Mark Wubben uncoveres a memory leak not caused by closures. Caused by circular references in the window object and global attributes on the same object.

• Two Browsers -- Sam Ruby details some of the JavaScript and dynamic style problems he's run into converting his presentation slide system to work in Internet Explorer. The comments highlight a number of solutions and workarounds. DOM Scripting isn't complete intuitive just yet.

• innerHTML vs. DOM = pot noodles vs. real cooking -- Chris Heilmann summarises the ongoing discussion about innerHTML versus DOM methods, and reaches a number of sensible conclusions.

• The XMLHttpRequest Object -- W3C Working Draft (via diveintomark)

• A Base Class for JavaScript Inheritance -- A base class that offers a cleaner way of extending and inheriting methods and attributes

• Introducing DOM Builder -- Object Notation way of building DOM structures

• AJAX Resources for Beginners -- Good list of resources to get yourself started.

• Learning Flash for programmers? -- I wonder if Simon Willison has reached the same conclusion I think I'm reaching: Flash is a decent platform for web-based, or web facing, applications. Perhaps even a complete replacement for AJAX.

• Introduction to JavaScript (ETech 2006 Tutorial) -- Phil Windley blogs a number of useful JavaScript tips from Simon Willison's ETech session

• JSON in JavaScript -- Contains a 'safe' JSON parser and stringify functions

• Particle Tree: More love For JSON -- Getting started with using JSON for AJAX applications

• JavaScript reserved words -- 'You should avoid using these reserved words and keywords as function or variable names as JavaScript has reserved these words for its own use.'

• JavaScript Object Notation for the masses -- Note to self: JSON is used in AJAX applications to send data from a server to a javascript function, as well as a way of writing JavaScript code (Object Literal). Bargain!

• Show love to the object literal -- 'The new syntax is called the object literal and is pretty close to sliced bread.' The advantage is that it allows you to 'namespace' your variables and methods.

• QuirksMode: DOM Compatibility tables: Attributes -- Browser support for DOM attributes is 'A bloody mess.'. Go for formField.value instead of formField.getAttribute('value') first.

• 24 Bottles Of Beer -- Dean Edwards blogs about how DOM attributes and DOM properties are handled differently by browsers. Standards compliant browsers keep them separate, IE doesn't

• OReilly: AJAX: How to Handle Bookmarks and Back Buttons -- A History Storage object for JavaScript enabled applications.

• Fixing the Back Button and Enabling Bookmarking for AJAX Apps -- Again based on the URL fragment as a means of saving the state of an application. This time using the Prototype library.

• Introducing JSON -- A good overview of JavaScript Object Notation, a simple data stucture approach to sharing data - especially, but not limited to, AJAX applications

• Developing Ajax applications that preserve standard browser functionality -- Uses fragment identifiers and window.location.hash to implement a simple state saver, thus making the browser back and forward buttons useful in an AJAX application. This approach is where I was leading up to with 'Fixing the back button that Ajax broke'.

• XULRunner 1.8.0.1 Release Notes -- First stable developer preview release of XULRunner. It provides facilities for launching standalone XUL applications and embedding APIs which can be used to render web pages within native and Java applications.

• JavaScript Tip #1: Speed Up Object Detection -- A simple genius solution to the constant object detection. Do it once, and remember

• JavaScript idioms every webdev should grok -- Everything in JavaScript is an object - even functions. Objects are mutable.

• Cheeky Tip: Default Function Arguments In JavaScript -- Useful technique of using default values in JavaScript

• Activity indicators -- A public domain collection of animated gifs for loading/waiting icons in AJAX applications. Useful.

• Yahoo! Developer Network - JavaScript Developer Center -- Links, articles, development guides and API documentation about JavaScript and Yahoo JavaScript-capable products

• Getting AJAX ready for prime time -- 'But the biggest obstacle to going Web-based is the fact that you need a big, fat pipe to the Internet whenever you want to work.'

• Top 10 custom JavaScript functions of all time -- Functions for adding events, cookie manipulation, and clever DOM shortcuts

• AJAX: Creating Huge Bookmarklets -- Brad Neuberg explains how to dynamically include a script element to create bookmarklets that use these external javascript files.

• Javascript libraries roundup -- Huge list of libraries and toolkits for developing JavaScript and AJAX powered applications.

• Patching start.com -- An interesting look at the JavaScript problems in start.com - its flawed because it patches Mozilla to act like Internet Explorer, rather than follow DOM standards.

• XMLHTTP notes: abort() and Mozilla bug -- PPK works his way through a number of oddities around stopping an active XmlHttpRequest

• The hows and whys of degradable Ajax -- strategies and techniques for building degradable Ajax applications

• What is GreaseMonkey? -- Mark Pilgrim describes this useful Mozilla/Firefox extension as well as showing what it can do.

• addEvent() recoding contest -- PPK is looking for an improvement to Scott Andrew's addEvent functions

• Developing Firefox Extensions with GNU/Linux -- Step by step guide to building a new Firefox extension, including a build script in Python

• Brain Jar: Bride of Windows -- JavaScript GUI window

• Faster DHTML in 12 Steps -- Optimising DOM manipulation. Beware, contains some IE specific code (via Nate Koechley)

• addEvent() considered harmful -- Peter Paul Koch explains the problems with Scott Andrew's useful addEvent functions

• FireAnt -- Omar Shahine talks about the AJAX framework being developed for the Hotmail Frontdoor rewrite.

• Moving Beyond the Basics: Scott Isaacs on AJAX Design Patterns -- List of problems that still need to be solved

• Remote Scripting with AJAX, Part 1 -- A short example with code examples for client and server

• Ajax Gotchas -- text/xml, IE caching and file locking

• developer.mozilla.org JavaScript documentation -- A JavaScript portal. References and articles.

• WaSP tackles JavaScript -- David Flanagan, author of 'JavaScript: The Definitive Guide' on the WaSP DOM Scripting TaskForce

• Understanding the Greasemonkey vulnerability -- Simon Willison explains the parts that combine to create this security hole. GreaseMonkey are taking action.

• CNet: Standards activists target scripts -- 'The WaSP DOM Scripting Task Force proposes to solve this problem by the adoption of unobtrusive DOM scripting, a way of thinking based on modern, standards-compliant, accessible Web development best practices.'

• Web Standards Project announces the DOM Scripting Task Force -- We want to make JavaScript a useful part of a web designers toolbox. I want to focus on JavaScript and accessibility.

• DOM Scripting Task Force -- A new face-lift for JavaScript. Modern and unobtrusive. Accessibility is also part of the picture

• Six JavaScript features we do not need any longer -- document.write, javascript:, noscript, document.all

• Dive into GreaseMonkey: Chapter 4. Common Patterns -- A goldmind of Javascript DOM patterns.

• Efficient JavaScript code -- Logical optimisations that keep JavaScript code running as fast as possible

• You should've been @media - part 2 -- PPK talks about our plans to encourage DOM scripting. Accessible JavaScript is on the agenda!

• Ajaxed out -- Summary of the O'Reilly Ajax Summit

• DOM properties, collections and methods -- An excellent reference to DOM manipulation in JavaScript

• AJAX Patterns: Design Patterns for AJAX Usability -- Answering the question: 'Why Ajax patterns' for XmlHttpRequest apps

• XMLHttpRequest Tracing for AJAX debugging -- Greasemonkey script that logs XmlHttpRequest requests and responses

• Ajax Mistakes -- Top 10 mistakes using XmlHttpRequest to dynamically update content

• Sitepoint: Closures and executing JavaScript on page load -- Closures can be used for onreadystatechange to avoid needing global variables

• Slashdot: Ajax buzzwords reinvigorates Javascript -- Using closures for onreadystatechange to get around global variable problems

• Ajax Patterns -- client-side and server-side patterns for XmlHttpRequest based applications

• Design Patterns in JavaScript: Singleton Design Pattern -- using an anonymous constructor

• Higher-Order JavaScript -- Extreme JavaScript - looks like Perl gurus let loose on JavaScript

• Dive into greasemonkey -- Mark Pilgrim is back with another awesome online book.

• Don't be degrading -- Phil Ringnalda on building Javascript dependent web applications - an excellent piece of wisdom

• Writing User Scripts -- Authoring Greasemonkey scripts - uses anonymous functions to prevent global clobbering

• Who needs XML? -- Scott Andrew questions the need for the XML portion in AJAX - if your frontend is always going to be JavaScript then using JavaScript objects like JSON is viable

• Ten good practices for writing JavaScript in 2005 -- Focusing on unobtrustive JavaScript and DOM

• DOM-Scripted Lists, Revisited -- gazingus improves on his original list-based DHTML menus (via kayodeok)

• JavaScript shell -- interactive command line interface for JavaScript and DOM

• Introducing JSON -- JavaScript Object Notation - machine readable data interchange, great for XmlHttpRequest applications

• DHTML Accessibility - Fixing the JavaScript Accessibility Problem -- demoing a drop-down menu and updatable spreadsheet that works in Firefox and WindowEyes. This presentation is at CSUN

• Ajax, promise or hype? -- Usability and accessibility ideas from Quirksmode

• XULU - Cross Platform XML Application Framework -- cross-platform application framework based on the Mozilla codebase

• Enhancing Structural Markup with JavaScript -- Scott Andrew's functions to add and remove javascript functions from event handlers

• AJAX and accessibility -- Practical suggestions on making XmlHttpRequest based applications accessible

• This is not another XMLHttpRequest article -- 'Market forces aside, from an accessible Internet perpective Google Maps perhaps lies on the border between acceptable JavaScript exclusion and unacceptable.'

• Changelog for Opera Beta 2 for Windows -- Atom Support and improved XmlHttpRequest support (Google Suggest now works)

• JavaScript and Accessibility. Pt. 2. -- Cross-browser form validation

• JavaScript and Accessibility. Pt. 1. -- 'Responsible scripting: Will this work if someone doesn’t have JavaScript available? If not, how can I provide an alternative?'

• Whitespace in the DOM -- Javascript functions to gracefully handle whitespace laden DOMs

• Curried JavaScript functions -- partially evaluating and recallable functions (based on shortage of mandatory parameters)

• Unobtrusive Javascript -- A developers guide to modern Javascripting

• ECMAScript Language Specification -- HTML version of the ECMAScript specification (via virtuelvis)

• ECMAScript Menu System -- Fantastic article about implementing an accessible dropdown menu system using DOM Scripting

• DHTML is dead. Long live DOM Scripting. -- 'Rather than trying to rehabilitate and redefine DHTML, I think it's time we ditched the term entirely.'

• 2005: The year of the DOM -- 'The challenge, of course, is accessibility: while JavaScript technologies allow for much improved interactivity they remain unavailable to a significant portion of user agents.'

• Writing an Extension for Firefox

• Following the trail to slim clients -- Gmail using XmlHttpRequest to pass information as Javascript function calls

• js-markdown -- Javascript implementation of markdown

• XMLHttpRequest for The Masses -- Google is using it extensively, the future is bright for XmlHttpRequest. Opera support coming soon!

• Optimizing JavaScript for Execution Speed -- 'choosing the right algorithm and data structure, refactoring to simplify code, minimizing DOM and I/O interaction, and using local optimizations last'

• Next generation web apps using REST, XML, XSLT, and XmlHTTPRequest -- FeedReactor - Javascript based news aggregator

• alt.lang.jre: Harnessing Rhino -- 'Learn the fundamentals of JavaScript on the Java platform'

• XML HTTP Request object. -- Opera 7.60 is starting to support XmlHttpRequest - Yipeee!!!

• XPath in JavaScript -- Another bit of the web application jigsaw puzzle falls into place

• Accessible JavaScript Examples -- Avoiding typical javascript traps

• Javascript AtomAPI Client using XmlHttpRequest -- How XmlHttpRequest makes Javascript a powerful scripting platform

• Advanced JavaScript and the Web's future -- Matt: 'What we need is to find what JavaScript developers have coded a million times, and make it a part of the base application platform'

• Safari and the HTTP Request Object -- Safari only supports GET and POST, and only text/xml Content-Type. Bizarre!

• HTML escapes the browser -- Safari webkit engine does all the magic

• Why Web Forms 2.0 isn't far enough to make a difference -- Javascript shims - javascript libraries don't work on the web

• Dynamic HTML and XML: The XMLHttpRequest Object -- supported in Safari 1.2

[ Weblog | Categories and feeds | 2011 | 2010 | 2009 | 2008 | 2007 | 2006 | 2005 | 2004 | 2003 | 2002 ]