jQuery

jQuery anchored the web for a generation, and a large share of production web code still runs on it. I work with it where the codebase already does, keeping behaviour organised and consistent rather than grandstanding about newer stacks.

My jQuery practice favours discipline: event delegation, unobtrusive behaviour separated from markup, and clean AJAX that degrades gracefully. These patterns make even aging interfaces maintainable and safe to extend.

Where modernisation is warranted, I migrate jQuery code to vanilla JS or a framework while preserving behaviour — the loss-free path is usually steady decoupling, not a rewrite.

Event delegation is the pattern that keeps big pages fast and stable. Rather than binding handlers to a hundred dynamic nodes, I delegate to a stable ancestor — so behaviour survives DOM churn and stays cheap even as the page grows.

Unobtrusive behaviour keeps markup clean. I separate the behaviour from the HTML and the structure from the script, which makes the interface readable and protects it from breaking when styles or scripts load out of order.

AJAX is written to degrade gracefully. Requests that fail should fall back, not break the page, so a flaky call surfaces as a notice rather than frozen UI — the same reliability discipline applied to a classic tool.

Long-lived codebases are treated with respect. Where a mature application already runs on jQuery, I keep its patterns consistent and documented instead of inflicting a trendy rewrite, because stability is a feature for business-critical UI.

When modernisation is warranted it is incremental. I decouple behaviour from jQuery piece by piece, introducing vanilla JS or a framework behind the same contracts, so the path is loss-free rather than a big-bang gamble.

jQuery is pragmatic legacy done well: reliable DOM and AJAX the web still runs on, maintained with discipline and migrated deliberately when that genuinely pays.

Event delegation keeps big pages fast and stable. I bind handlers to a stable ancestor rather than a hundred dynamic nodes, so behaviour survives DOM churn and stays cheap.

Unobtrusive behaviour keeps markup clean. Behaviour is separated from HTML and structure from script, protecting the interface from breakage when styles or scripts load out of order.

AJAX degrades gracefully. A failed request falls back to a notice rather than frozen UI, so flaky calls surface as a problem instead of breaking the page.

Long-lived codebases are respected. Where a mature app already runs on jQuery I keep its patterns consistent instead of inflicting a trendy rewrite.

Modernisation is incremental when warranted. I decouple behaviour from jQuery piece by piece, behind the same contracts, so the path is loss-free rather than a big-bang gamble.

Selectors are written to be efficient and clear. I avoid a hot loop of expensive DOM queries, keeping the page responsive as it grows.

I avoid coupling to global state. Handlers resolve what they need locally, making behaviour predictable and testable.

State changes are explicit. The interface reflects data through a clear path, so an update does not scatter across unrelated selectors.

jQuery is pragmatic legacy done well — reliable DOM and AJAX, maintained with discipline and migrated deliberately when that genuinely pays.