No more browser sniffing; jQuery.browser is now deprecated.

"Deprecated" means a bad practice; not going to be removed immediately but no schedule set.

jQuery.support now offers workarounds associated with MSIE:

• leading whitespace removal
• opacity support
• cloning permanently binds the events making it a "conjoined twin"

The test: A temporary div that that has several quirks for rendering that need to be worked around.

The question: "Do you do this the right way?", if not then do it the IE way.

Can be added as a new support properties associated with the test. jQuery core only has test that they care about.

All of the tests in support aren't lazy loaded since it only takes 4ms to load.

This mechanism for determining the capacity of an individual browser are more complicated than simple browser sniffing; see the documentation.

Now reflects the breakdown in the documentation.

Should make it easier to dyn load other portions of jQuery as needed.

TODO: querySelectorAll w/ find() http://www.w3.org/TR/selectors-api/

Mobile devices would be limited in the types of selectors and filtering that could be applied.

The use of $.getScript() would continue to use async load of modules with function invocation via the callback.

pdk has a mobile chart; conversations between the mobile device providers and jQuery: "Is getElementsByTagName()" required?"

What are the tradeoffs betwen dependency management and being explicit with imports

Is concat the best option for mobile? Almost certainly for desktop.

TODO: cache limits associated with iPhone 3 + Android + Palm

Embedding of jQuery in the browser likely not needed with the proliferation of the use of CDNs that manage the selection of the libraries and stable versions.

Sizzle uses an optimal approach to finding the particular selection rather than just relying on the right to left browser selection pattern.

TODO: jQuery Stack Profiler http://github.com/jwalsh/research/issues/#issue/21

TODO: FireUnit profile for CMO to determine top load for page.

Look at the requirements for

No anon functions.

Require the use of constructors (i.e., new String; new RegExp)

FF3.5 and Safari support for JSON parsing or the library support of JSON2.js (Crockford).

This could be used for how CMO structures the code. Some of the modules may look better than others.

There would now be a coherent set of test that are used for Function and Array (but with some reduction in the checks used for MSIE).

TODO: .selector / .context rsch

look at jQuery.fn.update as an example case.

• jQuery("div") == jQuery()

Rather than requerying for the document the find() is cached as the root.

• .first() & .last()

filter(":last") would be much slower than .last() .

• .data() now provides a coherent dump of all of the data.
• Document order is now enforced

Performance hit but one of the few libraries are

• Heights are now assumed
• $("#id").find("div") is still faster than $("#id div")

This is just just give the speed of the selector in

Check for any use of something like $("div", "#id") which is just weird.

• append() caches

Now uses fragment caching.

look at aching the same fragment then apply the ids with an attribute.

Caching for very small fragments (250 bytes): this would be something like $("<li>foo</li>").attr("id", "foo" + i).appendTo("ul")

var CMO = { ruhpInit: function() { }, profileInit: function() { }, }

Use appendTo() with the initial selector then use chaining for the click() bind.

This is just to hold on to a single object. Be wary of not chaining.

This is just for readability.

http://paulirish.com/2008/javascript-css-selector-engine-timeline/

When not in a stylesheet be aware of the differences in the selector engine style; would affect the Souder notes.

Consider just using tag.class on the right side of the selector and just a tag or a class on the left unless the first selector item is an id.

If the first item is just an id consider using the hyper-optimized:

$("#id").find("div")

since this by-passes all of the chunker code and just uses naive browser support.

This is important for :radio without and input as well as $("div > *") for any case.

If binding an event handler to more than three events consider using live() (contrast with livequery()).

register a selector on $(document).

TODO: jQuery.rule http://flesler.blogspot.com/2007/11/jqueryrule.html

1. Grab a reference to the node
2. Remove it from the DOM
3. Manipulate it
4. Add it back in

TODO: Determine how to convert this into a static rules for code review.

http://bit.ly/jqsource

Put boilerplate at the top of the plug-in definition:

if (!this.length) { return this; } ;

TODO: Check to see what the static module would want to run or how this is run with the site.

Compressors will really prefer to use consolidated var references:

var foo = 1, bar = 5, baz = "baz";

Would also be applied for things like constants.

var TRUE = true, FALSE = false, NULL = null, undefined, this = window;

This also minimizes the scope chain traversal (see the Yahoo!

TODO: Determine how this could be a performance gain.

TODO: Determine why one would use these structures. Seems complicated for passing values from bound && or || checks or from ternary checks.

http://compressorrater.thruhere.net/

What is a widget:

• something more than simply
• something that maintains state

• Pass in the function name as a param

Use openDiaglog

• Use prefixes for the UI object type
• Use chaining
• Use pure OO

This is available by default and has constructors but requires a call to _init() (though this will go away).

Question: how does the namespacing work with data().

TODO: Check how the data is getting stored with the constructors with the UI framework.

Without defining any functionality, first set up all the options that need to be supported.

1. Create the widget with the namespacing

cmo.timeline as an example.

1. Set up defaults as an object literal
2. Use metadata in class if required not with the constructor
3. Modify the state of the data in the DOM with metadata

http://plugins.jquery.com/project/metadata

1. Use the nomenclature of _ prefixing which is enforced
2. Monitor the use of trigger()

destroy: function() {}

is called assuming that the removal originates from jQuery and invokes remove() in the same way as html().

1. Define the namespace for widget

ui-cmo-timeline ui-cmo-timeline-nav ui-cmo-timeline-selected

This will only define the layout.

1. Set up the color information

Bind the structural elements to layout components.

.ui-widget-header .ui-widget-content

This is part of the advance selector on the theme builder.

Writing own framework is relatively trivial.

• Assertions

Most test suites can be fairly trivial in that it only requires an assertion system.

• Tests

The next level of abstraction lives at the level of a test consisting of multiple assertions.

• Async tests

This allows a queuing system for processing the tests.

Requires setting up the queue.

• Suites

Standalone or Runner

• QUnit
• JSUnit
• Selenium
• YUITest

are similar in popularity.

One method at a time.

Similar to unit but broken by task. Unconfirmed arguments about how the way someone writes behaviors or function assertions and the number of supported types.

• JSSpec
• Screw.Unit

http://pivotallabs.com/users/nick/blog/articles/433-screw-unit-a-new-js-testing-framework-version-0-1

The newest entry:

WebDriver - http://code.google.com/p/webdriver/

See the notes for additional options.

Look at Crosscheck via issue #24.

js-env has already been implemented at CMO.

Using both Page Speed and YSlow! is useful for various tests.

Parallel download now in ff3.5, chrome2…

The tools necessary to support the split are going to be a manual process: do this with the onload tests across all of CMO then apply the logic associated with Doloto:

http://research.microsoft.com/apps/pubs/default.aspx?id=70518

createElement("script") then check onreadystatechange.

Check that we're not using <script></script> invocations for ads that would block the parallel downloads in MSIE since this

Check the work provided by SS on the decision tree for the parallel downloading based on IFRAME or XHR requests.

The async requests could create problems if Web Developers aren't using the correct linkBuilder configuration to indicate the correct domains based on browser behavior.

Example given was just for technique 5 in the deck: onloadDone.

$.getScript abstracts this functionality.

Based on Even Faster Websites tool based on jQuery.

This is a sprite generation tool.

This updates the DOM on the fly

http://spriteme.org/

Look at decoupling the presentation classes from the data-* classes.

data bound into the DOM with listeners for the particular events: data() triggers setData event as part of jQuery internals (TODO: check the jQuery cookbook).

Custom events are bubbled in 1.3 (part of the Widget Factory); will need to upgrade to a current version before Q4.

Similar to Live.

1. Create action classes

Assume that you have any action-foo

1. Bind onAction

Use the plug-in to look for any event (click in the example) assocated with the class name.

1. Provide standard action and callbacks for the plug-in

return callback.apply

to support the call to onAction() using $(this) to reference the clicked element.

Look at an overall application.js file; this would just be the global function or a loader.

Consider structuring according to the type of the application you're running.

all.js: see the rules associated with how to determine what the load order is required.

Consider just pulling most of the files into the closure of

(function() { })(jQuery)

or whatever the required files.

cmo.

Look in particular for custom events.

Meta data:

Try this

jQuery(function($) {

});

for simplifying the closure.

Begin using the HTML5 for data structuring for having metadata: use the data- prefix attribute for elements.

For example:

…live("click", function() { …trigger("activated.foo") } );

…live("activated.foo", function() {});

This should also be considered with namespacing.

What should be done for the Rhino parsing of the JSON response with the templating language

Noted issue with the cache breaking with a query string; won't work. Research already completed.

Split the asset hosts against the new cmcdn.com domain:

s%d.cmcdn.com and s%d.stg2.cmcdn.com

config.action_{controller.assethost} =

This may change the eventual configuration associated with the graphics.base.url to be an asset.host.url