Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
jQuery

jQuery

Novice to Ninja
Turn a plain web page into a responsive interface, without sacrificing users when JavaScript fails.
by Earle Castledine 2010 407 pages
3.92
500+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Become a jQuery ninja by applying basics creatively, not memorizing APIs

Master the building blocks. jQuery is a JavaScript library for selecting and changing page elements, adding interactions, and communicating with a server. Most tasks follow a simple pattern: wait for the page, select elements, then apply actions. Its advantage is not a secret ability beyond JavaScript, but a consistent way to accomplish common jobs with less browser-specific work.

Practice beats cataloguing. The fictional StarTrackr! site gives the book a practical through-line: a basic celebrity table becomes a zebra-striped table, then menus, galleries, forms, and Ajax features. Each project reuses familiar ideas in a new setting. The authors' measure of expertise is creative application, not remembering every available command.

Analysis

What's striking is the book's emphasis on transfer: learn a small grammar, then use it to solve a growing range of interface problems. That resembles learning a musical instrument, where scales matter because they enable improvisation, not because scales are the performance. The abstraction is useful precisely because it lowers the cost of trying an idea. Its limit is equally important: a library can make code shorter without making the underlying behavior simpler, so understanding JavaScript and the DOM remains essential.

Use selectors that target exactly the elements your change should touch

Aim for a precise match. jQuery borrows CSS selector syntax, so developers can select by element, ID, class, relationship, or filter. For the celebrity table, selecting every row initially returns seven matches, not six, because the heading row is also a table row. Narrowing the selector to rows inside the table body fixes the mismatch.

Test before changing. The length property reports how many elements a selector found. If the result is unexpected, simplify the selector, check each part, and narrow it again. Filters such as even, first, and contains can refine a selection, while traversal methods move through parents, children, and siblings.

Analysis

A selector is more than a shortcut. It is an executable statement about which parts of a page belong to a behavior. That makes selector design a form of risk control: an overly broad match can quietly alter unrelated content. The book's length check is a simple but powerful debugging habit, akin to checking assumptions before running a data transformation. Concision matters, but a selector that another developer can understand is usually better than one that merely saves characters.

Build a useful page first, then enhance it for JavaScript users

Keep the baseline functional. Progressive enhancement means starting with a page that works without JavaScript, then adding richer behavior for browsers that support it. StarTrackr!'s disclaimer stays in the HTML, while jQuery adds a show or hide button only for users able to use it. A plain hyperlink can likewise remain useful if JavaScript is unavailable, even when JavaScript users receive an Ajax version.

Do not strand users. The book estimates that 5 to 10 percent of users at the time might browse without JavaScript, and describes adding a warning that JavaScript can remove. That percentage is historically situated, not a universal current statistic. The enduring design principle is to avoid controls that appear usable but do nothing.

Analysis

Progressive enhancement treats accessibility and resilience as properties of the starting design, not repairs added at the end. It also creates a useful failure mode: if a script fails, the page can still communicate its essential content. This approach does not automatically guarantee accessibility, since keyboard behavior, focus, and screen-reader semantics still require attention. But it creates a stronger foundation than making JavaScript responsible for whether the page works at all.

Put visual rules in CSS, and let jQuery switch classes

Keep presentation together. The book first colors alternate table rows by setting CSS properties directly through jQuery. The result works, but creates inline styles that are harder to maintain. A cleaner version puts the appearance in a CSS class, then uses addClass or removeClass to apply it. The same approach supports hover highlights and selected table rows.

Use direct styling selectively. Setting a CSS property through jQuery is still useful for values calculated at runtime, such as an element's position, or as a quick debugging aid. For ordinary visual rules, keeping styles in a stylesheet lets designers change the look without searching through behavior code.

Analysis

This is a practical form of separation of concerns: CSS describes appearance, while JavaScript changes which visual state applies. The distinction improves teamwork, testing, and future redesigns because each layer has a clearer job. It also resembles state-driven interface design, where the application changes a small state label rather than rewriting every visual property. The boundary is not absolute, however. Dynamic geometry and animation often need script-controlled values, so the useful rule is separation where it clarifies ownership.

Model interface behavior as events, state, and deliberate DOM movement

Listen for meaningful events. A document-ready handler waits until page elements exist; click, hover, blur, and scroll handlers respond to users or the browser. Inside a handler, `this` refers to the element that triggered the event. jQuery can also move a selection through the DOM, which lets a spoiler button reveal the answer beside it or a menu heading open its related list.

Control the event flow. Events can bubble from a child element to its parents. The book uses stopPropagation when a nested menu should not trigger its parent's handler, and preventDefault when a link's normal navigation should be replaced. Classes and jQuery's data storage can record whether a component is open, selected, or waiting.

Analysis

The event model makes interface behavior legible: something happens, a handler responds, and a state changes. That is a useful mental model for both small interactions and complex applications. Event bubbling can reduce duplicated handlers, but it also means behavior depends on the surrounding DOM structure. Developers benefit from treating propagation as part of the design rather than a browser quirk. The book's state examples are deliberately modest, which helps beginners see that a class can communicate meaningful application state.

Animate to clarify a change, not to decorate every interaction

Make movement serve feedback. jQuery's basic effects fade, slide, show, hide, or animate CSS properties. A duration controls timing, easing changes acceleration, and callbacks run after an effect completes. The book uses these tools for content panes, menus, and a moving navigation highlight, while warning that visual effects need restraint.

Manage motion deliberately. Animations queue by default, so quick mouse movements can create a backlog. The stop method clears or finishes queued work, and disabling the queue can let simultaneous animations run. Scroll events can fire repeatedly as a user moves the page, so stopping an earlier animation helps prevent a floating navigation element from jittering.

Analysis

Motion is most informative when it reveals a relationship, such as a panel opening from its heading or a notice fading after an action. It can also impose cognitive and sensory costs when it is frequent or ornamental. Modern interface practice adds another useful question: can the same information be conveyed without motion for people who prefer reduced animation? The book's emphasis on restraint supports that question, even though its examples focus more on visual polish than on motion preferences.

Give each widget its own scope, state, and clear responsibilities

Contain growing complexity. As StarTrackr!'s features expand, the book groups related variables and methods into named objects such as a gallery or tooltip widget. Namespacing reduces the chance that one script will overwrite another's functions. A local reference to the widget also preserves access to its state inside event or Ajax callbacks, where `this` may refer to something else.

Keep jobs separate. The gallery separates loading images from displaying them. A table template stays in the HTML, while a helper fills a cloned row with data. Comments, named functions, and saved selections make the code easier to revisit and reuse than a long chain of anonymous handlers.

Analysis

The move from isolated commands to small components is a shift from scripting to software design. Encapsulation gives each widget a boundary, while separated responsibilities make changes easier to test. The book's examples show the benefit without requiring an elaborate framework. There is a counterweight: packaging every three-line interaction into a named system can add needless ceremony. A component earns its structure when it is reused, has state, or has enough moving parts to deserve a boundary.

Make Ajax responsive, but plan for slow, failed, and empty requests

Update without a page reload. Ajax lets a browser request server data and update part of a page. StarTrackr! uses it to load celebrity biographies, fetch image lists, and retrieve tags. A regular link can remain the fallback while JavaScript intercepts it, a technique the book calls Hijax. Responses may be HTML, JSON, or XML, which jQuery can help process.

Show what is happening. Loading indicators and global Ajax events make requests visible to users. The book also recommends timeouts and a limited retry strategy with increasing delays, called exponential backoff. Its examples note that ordinary requests are restricted to the same domain, while JSONP can work with compatible services across domains.

Analysis

Ajax turns a page into a conversation with a remote system, and remote systems are less predictable than local interface code. A spinner addresses uncertainty, while a timeout and error message prevent an interaction from appearing frozen. Retries need care: repeating a request that changes server data can create duplicate effects if the first response was merely lost. That is a distributed-systems problem, not just a jQuery problem. The book's key contribution is to make failure handling part of the interface rather than an afterthought.

Borrow mature widgets when their breadth beats a custom solution

Reuse tested building blocks. jQuery UI supplies controls such as accordions, tabs, dialogs, date pickers, sliders, and drag-and-drop behaviors. Plugins extend the same idea with features such as image lightboxes, cropping interfaces, and autocomplete. They can replace substantial custom work, while themes help make interface elements visually consistent.

Choose with care. A custom lightbox is reasonable when only a basic image display is needed; a fuller plugin makes sense when galleries, options, and callbacks matter. The book advises checking documentation and code, since some plugins may be old or larger than the task requires. jQuery UI's download builder also allows developers to include selected components rather than the entire library.

Analysis

Reusing a widget is a trade between development time and dependency cost. A mature component can encode years of edge-case work, but every dependency adds code that must be understood, maintained, and trusted. The book's practical test remains strong: compare the required behavior with the plugin's actual feature set, rather than choosing by popularity alone. A smaller custom solution can be better for a narrow need, while a complex date picker is often a poor place to improvise.

Make forms coach users, while validating every submission on the server

Guide the person filling the form. jQuery can inspect values, check whether fields are empty, and respond to blur or submit events. The book demonstrates inline error messages, hints inside simple inputs, character counters, and a validation plugin for rules such as required fields, email formats, and matching passwords. jQuery UI can add date pickers and sliders when ordinary inputs are awkward.

Keep the server in charge. Client-side checks help users correct mistakes before submission, but they cannot secure an application because users can disable JavaScript or bypass the page. The authors explicitly require server-side validation where submitted data creates security risks. They also caution against excessive rules that reject reasonable input variations.

Analysis

Good validation is a dialogue, not a gate slammed shut after submission. Timely feedback can make requirements understandable and reduce avoidable errors, especially when the form shows what is acceptable. Yet validation rules encode assumptions about people and their data; overly rigid rules can exclude legitimate entries. Separating helpful client feedback from authoritative server checks is therefore both a security practice and a humane design choice. The distinction prevents convenience features from being mistaken for trust boundaries.

Keep lists structurally consistent so menus, trees, and selection stay simple

Let structure do the work. Nested lists can represent expandable menus, accordions, and trees of categories. When each level follows the same markup pattern, a short selector can find a heading, its child list, and the control that opens it. The book also uses jQuery UI Selectable to choose tags, find duplicates, and mark approved or rejected items.

Reuse the same data shape. A list of names can be sorted alphabetically, while select-box options can be moved between candidate and A-list groups. These operations are easier when the HTML has consistent parent-child relationships. For unusual interactions such as selecting a continuous range, the book stores the previous selection and uses the Shift key state.

Analysis

Lists are useful because they expose relationships plainly: membership, order, and nesting are already present in the markup. That makes them a natural substrate for interactive controls, rather than a visual trick. The same consistency also helps server-generated content behave like hand-written examples. The limitation is that dense nested menus can become hard to navigate, even if the code is elegant. Choosing a control should depend on how users understand the categories, not only on how easily a tree can be built.

Turn tables into manageable grids without losing track of their data

Preserve the table's purpose. Tables belong to tabular data, and jQuery can make them easier to scan with alternating row styles, highlighted rows, and fixed or repeated headers. The book extends a celebrity table with pagination, editable cells, sortable rows, and checkbox selection. Paging is useful when only part of a modest data set needs to be visible at once.

Keep interaction tied to records. When a row enters edit mode, its cell values are stored before inputs replace the display. Checkbox selections can be collected for processing, including ranges selected with Shift. For larger feature sets, a data-grid plugin may provide sorting, searching, paging, and Ajax loading, but a custom grid may be leaner when requirements are limited.

Analysis

The table examples show how interface quality depends on preserving the relation between a visible cell and the underlying record. Editing, sorting, and paging are not merely visual effects; they change how people interpret and manage data. That makes clear status, stable headers, and recoverable edits more important than decorative polish. A grid also accumulates complexity quickly, so the choice between a custom control and a plugin should be based on data volume and user tasks, not on the appeal of a feature list.

Analysis

This is a practical programming tutorial organized as a client project. A fictional celebrity-tracking site, StarTrackr!, supplies a reason for each new technique: first alter a table, then build menus and galleries, then add Ajax, forms, and administrative tools. That narrative makes a large API feel like a sequence of jobs rather than a dictionary to memorize. Its central teaching is compositional. Selectors identify targets, actions change them, events connect behavior to user activity, and small functions or plugins package repeated work.

The strongest ideas are not tied to jQuery: preserve a usable baseline, separate presentation from behavior, test assumptions, manage state, and make remote failures visible. The technical examples show how a handful of operations can produce surprisingly rich interactions. The book is also unusually clear that jQuery remains JavaScript, and that plugins should not replace judgment about which tool suits a task.

The limits are historical. Published in 2010, the examples use an early jQuery ecosystem, including APIs and plugin practices that should not be copied blindly into current projects. Its focus on browser compatibility and visual widgets reflects its period, while modern development also demands attention to security, accessibility, performance, and maintainability across a broader device landscape. Those caveats do not erase the instructional value. They change what should be retained: the problem-solving method, not the literal code.

A useful reading is therefore two-layered. Treat the StarTrackr! examples as a record of how front-end developers learned to build interactive pages with a compact library. Then extract the durable engineering habits: start with working HTML, keep selectors precise, make state explicit, isolate reusable behavior, and handle failure as part of design. The book's promised transformation from novice to ninja is best understood as a change in judgment. The expert is not the person who uses the most effects, but the person who can combine simple tools into a usable interface and knows when not to add more.

Summary in 30 Seconds
jQuery combines precise element selection with actions that change page content and behavior. Start with functional HTML, then add JavaScript features while preserving useful fallbacks. Keep visual rules in CSS, track interface state clearly, and use events to coordinate interactions. Ajax needs visible loading feedback and plans for failure. Client-side form checks help users, but server validation remains essential.
Contains spoilers

Last updated:

Report Issue

Review Summary

3.92 out of 5
Average of 500+ ratings from Goodreads and Amazon.

JQuery novice to ninja receives mixed reviews, with an average rating of 3.92/5. Many readers find it a solid introduction for beginners, praising its clear language and practical examples. The book is commended for its hands-on approach and humor. However, some experienced developers find it too basic. Critics note that it may be outdated for current web development practices. While it provides a good foundation, some argue it doesn't reach "ninja" level as the title suggests. Overall, it's considered a useful resource for those new to jQuery.

Your rating:
4.45
149 ratings
Want to read the full book?

Glossary

jQuery

JavaScript interaction library

A JavaScript library that simplifies selecting and manipulating page elements, handling events, adding effects, and making Ajax requests. It uses CSS-like selectors and offers a consistent interface that historically reduced the amount of browser-specific code developers needed to write. The book presents it as a practical layer over JavaScript, not as a replacement for understanding the language.

Document Object Model (DOM)

Tree of page elements

The browser's structured representation of an HTML document. Elements form a hierarchy of parents, children, and siblings, and JavaScript can inspect or alter that structure. jQuery selectors find elements in the DOM, while traversal methods move from one related element to another. Understanding this tree makes it easier to reason about where content is inserted, hidden, or changed.

Progressive enhancement

Enhance a working baseline

A development approach that starts with useful HTML content and functionality, then layers on JavaScript behaviors for browsers that support them. The underlying page remains usable if scripts do not run. In the book's examples, links and disclaimers work in the basic page, while jQuery adds richer controls without making those controls the only route to the content.

Hijax

Ajax-enhanced ordinary links

A technique for intercepting a normal hyperlink with JavaScript and replacing its page navigation with an Ajax request. The link remains an ordinary route when JavaScript is unavailable, while JavaScript users can load the linked content into the current page. The book uses celebrity biography links to demonstrate this gradual enhancement.

Ajax

Background browser-server requests

A broad term for techniques that let a browser exchange data with a server and update part of a page without a full page reload. The book uses jQuery methods to load HTML, request JSON or XML, and submit form data. It also emphasizes that requests can be slow or fail, so interfaces need indicators, timeouts, and error handling.

Event propagation

Events bubble through ancestors

The movement of an event from the element where it occurs up through its parent elements in the DOM. This lets a parent respond to activity on a child, but can also cause multiple handlers to react to one click. jQuery's event methods can stop propagation or prevent a browser's default response when an interaction requires different behavior.

Event delegation

Handle child events at a parent

A pattern that places one event handler on a common ancestor instead of attaching separate handlers to many child elements. The parent examines which descendant triggered the event and responds accordingly. This can reduce duplicated handlers and support dynamic content, but depends on the event continuing to bubble to the parent.

Namespacing

Group related code safely

Organizing related variables and functions under a distinctive object name so they are less likely to collide with other scripts. The book uses named objects for widgets such as galleries and tooltips. It also applies namespacing to event handlers, allowing a group of related handlers to be removed without disturbing unrelated behavior.

JSONP

Callback-wrapped cross-domain data

A data-delivery technique that uses a script request and a named callback to receive JSON-like data from a compatible external service. The book introduces it as an option when a browser's same-domain restrictions prevent a direct Ajax request. It depends on the service supporting the format and requires care because returned script is executed by the page.

ThemeRoller

jQuery UI theme designer

A visual tool described in the book for customizing the appearance of jQuery UI components. Developers can adjust theme colors, borders, fonts, and related styles, preview the results, and download the resulting CSS. The same styling conventions can be applied to custom widgets so they can share a consistent theme.

FAQ

What is "jQuery: Novice to Ninja" by Earle Castledine about?

  • Comprehensive jQuery resource: The book is a practical, step-by-step guide to mastering jQuery, starting from the basics and advancing to complex topics like Ajax, UI widgets, and plugin development.
  • Focus on interactivity: It teaches readers how to transform static HTML and CSS into dynamic, interactive web applications using jQuery and jQuery UI.
  • Target audience: Designed for front-end developers and designers with intermediate HTML/CSS skills and some programming experience who want to build rich, user-friendly web interfaces.
  • Project-based learning: Uses a fictional project, StarTrackr!, to demonstrate real-world applications of jQuery concepts throughout the book.

Why should I read "jQuery: Novice to Ninja" by Earle Castledine?

  • Structured learning path: The book offers a clear progression from fundamental jQuery concepts to advanced techniques, making it suitable for both beginners and those seeking deeper expertise.
  • Emphasis on best practices: It stresses clean code, maintainability, progressive enhancement, and accessibility, preparing readers for professional web development.
  • Hands-on examples: Real-world projects and practical coding exercises help solidify understanding and provide immediate, applicable skills.
  • Comprehensive coverage: Covers everything from selectors and animations to plugin development and theming, ensuring a well-rounded mastery of jQuery.

What are the key takeaways from "jQuery: Novice to Ninja" by Earle Castledine?

  • Write less, do more: jQuery simplifies JavaScript tasks, allowing developers to achieve complex results with concise, readable code.
  • Separation of concerns: Encourages keeping HTML markup clean by attaching behaviors externally, leading to more maintainable and scalable codebases.
  • Cross-browser compatibility: jQuery handles browser inconsistencies, ensuring code works uniformly across different environments, including older browsers like IE6.
  • Extensibility and plugins: The book highlights jQuery’s plugin architecture, enabling easy extension and customization of functionality.

How does "jQuery: Novice to Ninja" by Earle Castledine explain the basics of jQuery syntax and selectors?

  • Core jQuery function: Introduces the jQuery() function and its $() alias, which are used to select elements and chain actions.
  • Selector syntax: Explains how to use CSS-style selectors to target elements by tag, id, class, attributes, and hierarchy.
  • Filters and chaining: Demonstrates the use of filters like :first, :last, :even, and :odd to refine selections, and shows how to chain multiple actions for concise code.
  • Practical examples: Provides hands-on exercises to reinforce selector concepts and best practices for efficient element targeting.

What animation and effects techniques are covered in "jQuery: Novice to Ninja" by Earle Castledine?

  • Built-in effects: Covers core animation methods such as fadeIn, fadeOut, slideDown, slideUp, and toggle, including timing and callback usage.
  • Advanced animations: Teaches the .animate() method for animating multiple CSS properties with fine control, including relative values and easing functions.
  • jQuery UI effects: Introduces additional effects like shake, highlight, and explode from the jQuery UI library for enhanced interactivity.
  • Chaining and queues: Explains how to chain animations and manage animation queues for smooth, complex sequences.

How does "jQuery: Novice to Ninja" by Earle Castledine approach Ajax and dynamic content loading?

  • Ajax fundamentals: Explains asynchronous server communication using jQuery’s $.ajax method and its simpler wrappers like $.get, $.post, and $.getJSON.
  • Practical Ajax examples: Walks through building Ajax-powered features such as image galleries, dynamic content loading with .load(), and handling JSON/XML data.
  • Error handling and feedback: Covers best practices for managing errors, using global Ajax event handlers for spinners, and providing user feedback during Ajax operations.
  • Progressive enhancement: Introduces the Hijax technique to ensure links work with or without JavaScript, maintaining accessibility.

What form validation and control techniques are explained in "jQuery: Novice to Ninja" by Earle Castledine?

  • Form validation basics: Shows how to use jQuery selectors and events for simple and inline form validation.
  • Validation plugin: Introduces the jQuery Validation plugin for robust, customizable validation with rules like required, email, minlength, and equalTo.
  • Advanced form features: Explains implementing maximum length indicators, inline editing, autocomplete, and star rating controls using plugins and custom code.
  • User experience focus: Emphasizes progressive enhancement, disabling/enabling fields during Ajax calls, and providing clear feedback for accessible, user-friendly forms.

How does "jQuery: Novice to Ninja" by Earle Castledine enhance lists, trees, and tables?

  • List enhancements: Demonstrates multi-item selection with jQuery UI Selectables, sorting lists, and manipulating select box lists with swapping and searching.
  • Tree structures: Shows how to create expandable/collapsible trees using nested lists, toggle handles, and event delegation for efficient handling.
  • Table improvements: Covers fixed headers, repeating headers, data grids with pagination and inline editing, and row/column selection with checkboxes and shift-select.
  • Real-world examples: Provides practical code samples for each enhancement, making it easy to apply these techniques to actual projects.

What guidance does "jQuery: Novice to Ninja" by Earle Castledine provide for plugin development?

  • Creating plugins: Explains how to convert jQuery code into chainable, reusable plugins by extending $.fn and handling each element individually.
  • Options and callbacks: Covers adding customizable options with defaults using $.extend, and implementing setup and completion callbacks for flexible plugin usage.
  • Advanced plugin topics: Teaches extending jQuery with $.fn.extend and $.extend, creating utility functions, and writing custom selectors to expand jQuery’s capabilities.
  • Best practices: Emphasizes returning the jQuery object for chaining and using event namespaces to avoid conflicts.

How does "jQuery: Novice to Ninja" by Earle Castledine explain event handling and custom events?

  • Standard event binding: Details how to bind and unbind events, use event delegation for performance, and access event properties like target and timeStamp.
  • Custom events: Shows how to create and trigger custom events for modular, reusable code, and how to namespace events for selective unbinding and triggering.
  • Special and device events: Covers jQuery’s special event hooks and handling device-specific events, such as iPhone touch events, by accessing originalEvent properties.
  • Plugin integration: Demonstrates how event handling techniques are essential for robust plugin development and UI interactivity.

What UI controls and widgets are demonstrated in "jQuery: Novice to Ninja" by Earle Castledine?

  • jQuery UI components: Teaches how to use accordions, tabs, sliders, date pickers, progress bars, dialogs, sortable lists, and drag-and-drop helpers.
  • Custom controls: Shows how to build star rating controls, inline editing fields, and notification systems for user feedback.
  • User experience enhancements: Includes techniques for adding spinners during Ajax calls, floating navigation, animated menus, and slide-down login forms.
  • Consistent theming: Explains how to apply jQuery UI themes for a professional, cohesive look across all widgets.

How does "jQuery: Novice to Ninja" by Earle Castledine address theming, styling, and cross-browser issues?

  • ThemeRoller integration: Explains how to use jQuery UI’s ThemeRoller tool to customize and apply themes to UI components.
  • Making components themeable: Advises adding UI classes like ui-widget and ui-corner-all to custom components for consistent styling.
  • Cross-browser considerations: Discusses limitations in older browsers (e.g., IE6) and suggests using PNG support libraries and fallback styles for compatibility.
  • Professional appearance: Emphasizes the importance of theming and styling for creating polished, user-friendly interfaces.

What are the best quotes from "jQuery: Novice to Ninja" by Earle Castledine and what do they mean?

  • “Write less, do more.” Captures jQuery’s philosophy of simplifying JavaScript development by enabling powerful results with minimal code.
  • “Becoming a ninja isn’t about learning an API inside out and back to front—that’s just called having a good memory.” Stresses that true expertise comes from creative problem-solving, not rote memorization.
  • “jQuery is a tool to help us improve the usability of our sites and create a better user experience.” Highlights the book’s focus on practical, user-centered web development.
  • “When the only tool you have is a hammer, everything looks like a nail.” Warns against overusing jQuery for tasks better handled by HTML or CSS, advocating for thoughtful tool selection.

About the Author

Earle Castledine is an author known for his work on web development and programming topics. Earle Castledine wrote "JQuery novice to ninja," which aims to provide a comprehensive introduction to the jQuery JavaScript library. The book is designed to take readers from beginner to advanced levels in using jQuery for web development. Castledine's writing style is often described as engaging and humorous, making technical content more accessible to readers. His approach focuses on practical examples and real-world applications, helping readers quickly apply their newly acquired knowledge. While specific details about Castledine's background and other works are not provided, his book has been widely read and reviewed in the web development community.

Download PDF

To save this jQuery summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.42 MB     Pages: 24

Download EPUB

To read this jQuery summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.36 MB     Pages: 30
Want to read the full book?
Follow
Listen8 mins
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 24,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
600,000+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...