jQote2

jQote2 is the second major release of jQuery’s most powerful and versatile client-side templating engine. Version 2 now incorporates a faster and more accurate parsing/conversion part that does away with its predecessor’s shortcomings in escaping quotes and multiline support.


http://aefxx.com/jquery-plugins/jqote2/
https://github.com/aefxx/jQote2

Slanger

Slanger is an open source server implementation of the Pusher protocol written in Ruby. It is designed to scale horizontally across N nodes and to be agnostic as to which Slanger node a subscriber is connected to, i.e subscribers to the same channel are NOT required to be connected to the same Slanger node. Multiple Slanger nodes can sit behind a load balancer with no special configuration. In essence it was designed to be very easy to scale.

Presence channel state is shared using Redis. Channels are lazily instantiated internally within a given Slanger node when the first subscriber connects. When a presence channel is instantiated within a Slanger node, it queries Redis for the global state across all nodes within the system for that channel, and then copies that state internally. Afterwards, when subscribers connect or disconnect the node publishes a presence message to all interested nodes, i.e. all nodes with at least one subscriber interested in the given channel.

Slanger is smart enough to know if a new channel subscription belongs to the same user. It will not send presence messages to subscribers in this case. This happens when the user has multiple browser tabs open for example. Using a chat room backed by presence channels as a real example, one would not want "Barrington" to show up N times in the presence roster because Barrington is a retard and has the chat room open in N browser tabs.

Slanger was designed to be highly available and partition tolerant with eventual consistency, which in practise is instantaneous.

https://github.com/stevegraham/slanger

Programming With Nothing

Ruby is a powerful language, but how much power does it have if you remove all of its datatypes except for Proc and all of its features except for Proc.new and Proc#call?

Contents

• Ruining Ruby
• Thinking procs
• Aiming high
• Numbers
• Booleans
• Predicates
• Numeric operations
• Lists, briefly
• Strings, briefly
• Victory
• Why?
• Epilogue

http://experthuman.com/programming-with-nothing

BREAKPOINTS.JS

Define breakpoints for your responsive design, and Breakpoints.js will fire custom events when the browser enters and/or exits that breakpoint. Get it from Github.

http://xoxco.com/projects/code/breakpoints/

Humane JS

A simple, modern, framework-independent, well-tested, unobtrusive, notification system. Utilizes CSS transitions when available, falls back to JS animation when not. Includes mobile support.

http://wavded.github.com/humane-js

KeyboardJS

What is KeyboardJS? 
KeyboardJS is a library for binding to keys or key combos. Its available as an AMD module or a standard Library.
Language Support
KeyboardJS is for binding to keyboards with the US character set. Adding other character sets is possible by editing the key code map variable named 'keys' in the module.

http://robertwhurst.github.com/KeyboardJS

RequireJS

RequireJS is a JavaScript file and module loader. It is optimized for in-browser use, but it can be used in other JavaScript environments, like Rhino andNode. Using a modular script loader like RequireJS will improve the speed and quality of your code.

http://requirejs.org/

Principles of Writing Consistent, Idiomatic JavaScript

Important, Non-Idiomatic Stuff:

Code Quality: Awesome Tools, Resources & References

• jsPerf
• jsFiddle
• jsbin
• JavaScript Lint (JSL)
• jshint
• jslint

Leveraging Code Quality Tools by Anton Kovalyov

Get Smart

http://es5.github.com/

The following should be considered 1) incomplete, and 2) REQUIRED READING. I don't always agree with the style written by the authors below, but one thing is certain: They are consistent. Furthermore, these are authorities on the language.

• Eloquent JavaScript
• JavaScript, JavaScript
• Rebecca Murphey or Adventures in JavaScript Development
• Perfection Kills
• Douglas Crockford's Wrrrld Wide Web

Build & Deployment Process

Projects should always attempt to include some generic means by which source can be compressed in preparation for production use. Some popular and proven tools include the JavaScript-based Uglify.js, as well as the Java-based Google Closure Compiler and YUI Compressor. Choose one and support it.

You can now find a functional, generic "build kit" in the /kits directory of this repository. Usage is easy: 1) copy the contents of a kit found in /kits to a new working directory, 2) save your project .js file in the /src directory, 3) put the name of the project in project.txt, 4) run make from command line. (Even easier directions: replace occurrences of "foo")

Test Facility

Projects must include some form of unit, reference, implementation or functional testing. Use case demos DO NOT QUALIFY as "tests".

• QUnit
• Jasmine
• Vows
• Hiro
• JsTestDriver

Table of Contents

• Whitespace
• Beautiful Syntax
• Type Checking (Courtesy jQuery Core Style Guidelines)
• Conditional Evaluation
• Practical Style
• Naming
• Misc
• Native & Host Objects
• Comments

https://github.com/rwldrn/idiomatic.js

Efficient JavaScript

Traditionally, a Web page would not contain much scripting, or at least, not much that would affect the performance of that Web page. However, as Web pages become more like applications, the performance of scripts is having a bigger effect. With more and more applications being developed using Web technologies, improving the performance of scripts is becoming increasingly important.

With a desktop application, a compiler is normally used to convert the source into the final binary. The compiler can take its time, and optimize as much as possible for good performance of the final application. Web applications do not have that luxury. Since they need to run on multiple browsers, platforms, and architectures, they cannot be completely precompiled. The browser has to do the interpretation and compilation each time it retrieves a script, and yet the final application has to run as smoothly as a desktop application, and load quickly as well. It is expected to run on a large variety of devices, from an ordinary desktop computer, to a mobile phone.

Browsers are fairly good at achieving this, and Opera has one of the fastest scripting engines of any current browser. However, browsers do have their limits, and that is where the Web developer has to take over. Ensuring that a Web application runs as fast as possible can be a simple matter of trading one type of loop for another, making one combined style change instead of three, or adding only the script that will actually be used.

This article will show several simple changes that can be made to improve the performance of your Web applications. Areas covered will be ECMAScript - the core language used by JavaScript, DOM, and document loading.

ECMAScript

1. Avoid using eval or the Function constructor
   1. Rewrite that eval
   2. If you want a function, use a function
2. Avoid using with
3. Don't use try-catch-finally inside performance-critical functions
4. Isolate uses of eval and with
5. Avoid using global variables
6. Beware of implicit object conversion
7. Avoid for-in in performance-critical functions
8. Use strings accumulator-style
9. Primitive operations can be faster than function calls
10. Pass functions, not strings, to setTimeout() and setInterval()

DOM

1. Repaint and reflow
   1. Keeping the number of reflows to a minimum
   2. Minimal reflow
2. Document tree modification
3. Modifying an invisible element
4. Taking measurements
5. Making several style changes at once
6. Trading smoothness for speed
7. Avoid inspecting large numbers of nodes
8. Improve speed with XPath
9. Avoid modifications while traversing the DOM
10. Cache DOM values in script variables

Document loading

1. Avoid keeping alive references from one document to another
2. Fast history navigation
3. Use XMLHttpRequest
4. Create SCRIPT elements dynamically
5. location.replace() keeps the history under control

http://dev.opera.com/articles/view/efficient-javascript

Google Chrome Frame

• Enable open web technologies in Internet Explorer
  Google Chrome Frame is an open source plug-in that seamlessly brings Google Chrome's open web technologies and speedy JavaScript engine to Internet Explorer. With Google Chrome Frame, you can:
  
  • Start using open web technologies - like the HTML5 canvas tag - right away, even technologies that aren't yet supported in Internet Explorer 6, 7, 8, or 9.
  • Take advantage of JavaScript performance improvements to make your apps faster and more responsive.
• Get started with Google Chrome Frame
  Enabling Google Chrome Frame is simple. For most web pages, all you have to do is add a single tag to your pages and detect whether your users have installed Google Chrome Frame.
  
  • If Google Chrome Frame is not installed, you can direct your users to an installation page.
  • If Google Chrome Frame is installed, it detects the tag you added and works automatically.

http://code.google.com/chrome/chromeframe/

Modernizr

Modernizr is an open-source JavaScript library that helps you build the next generation of HTML5 and CSS3-powered websites.

Why use Modernizr?

Taking advantage of the new capabilities of HTML5 and CSS3 can mean sacrificing control over the experience in older browsers. Modernizr 2 is your starting point for making the best websites and applications that work exactly right no matter what browser or device your visitors use.

http://www.modernizr.com/