#Performance
32 notas · última:
Hydration and Incremental Hydration in Angular
The article explains hydration in SSR apps as client activation of server-rendered HTML, then shows how Angular 19 adds incremental hydration to trigger interactivity only when needed.
Frontend Design Patterns That Actually Work in 2026
The page outlines frontend patterns for 2026: component-driven development, container queries, accessibility-first libraries, AI-assisted workflows, and performance tactics that improve consistency, responsiveness, and maintainability.
Performance Principles
The page frames performance as reducing unnecessary work, shortening paths, caching repeated computations, and moving loading earlier with prefetching or preloading, including mobile-specific timing.
Angular’s Efforts To Be Easier and Developer Friendly
Angular says it is now simpler and more developer-friendly, with clearer template syntax, Signals, finer-grained lazy loading, partial hydration, and AI features such as structured output with Gemini.
21 Frontend System Design Concepts for Software Engineers
The article frames frontend engineering as system design in the browser, covering rendering models, performance, state, data fetching, architecture, UX, security, and observability.
Regression Towards the Mean - Mental Model
The page explains regression toward the mean as a statistical pattern in which extreme results are often followed by values closer to average, which can be mistaken for the effect of praise, plans, or other interventions.
Everything You Want to Know About the Record Type in .NET… But Were Afraid to Ask
The article presents record types in .NET 5 as a fit for model types such as DTOs and POCOs, with less boilerplate and built-in support for immutability. It also notes that records generate equality members, GetHashCode(), and a useful ToString(), while mentioning a custom PropertiesToString() for collection properties.
Performance Improvements in .NET 9
A release tour of .NET 9 performance work across the JIT, GC, runtime, libraries, and tooling, with benchmarked gains in casts, loops, bounds checks, vectorization, LINQ, regex, JSON, networking, and more.
How to make your Express.js APIs 9x faster with Encore.ts
The guide shows how to migrate an Express.js app to Encore.ts to gain type-safe APIs, a Rust runtime, and a 9x performance boost, with partial or complete migration.
Boosting Performance With Sealed Classes in .NET
The article compares open and sealed classes in C# and shows gains in performance in method calls, casting, type checking, and arrays, with an exception for static methods. It also points out the cost for mocking in tests.
99% of frontend devs don't use this
Antonio Moruno Gracia argues data-* attributes beat closures inside React's .map() when React.memo or useCallback need a stable function reference to actually work.
How To Use Multithreading in Node.js
The tutorial explains why CPU-bound work blocks Node.js, how worker_threads move that work off the main thread, and how pools, limits, and monitoring keep multithreaded apps stable.
Subalternidade como performance
Conceito articulado por Natânia Lopes em Cabaré: a puta executa de saída a postura tradicional da mulher subalterna — carinhosa, atenciosa, chamando o cliente de amor — como técnica de trabalho, não como submissão real. A doçura é dispositivo, não acomodação. Cruza com Goffman, Butler e a antropologia da performance.
Logging Performance Improvements with Source Generators in C# .NET
The post explains how source-generated logging in .NET uses `LoggerMessage` on partial methods to reduce overhead, improve type safety, cut boilerplate, and keep log messages consistent.
How to Implement Response Caching for Improved Performance?
Response caching stores API or web app responses in a cache so later requests can reuse them faster. The post lists benefits, request types, constraints, real-world uses, and a simple Postman test.
Code Smell 155 — Multiple Promises
Waiting for promises one by one creates indeterminism and a performance bottleneck. If all results are needed, they should be awaited together with Promise.all.
Caching things every Programmer must know
The article explains what caching is, when it matters, its benefits, cache memory levels, common cache types, distributed caching, hit and miss, cache strategies, and eviction policies.
Resources for F# Onboarding
Curated links for learning F#, covering official docs, functional programming, code architecture, testing, performance, and people to follow on Twitter.
How Ruby Uses Memory
The article explains how Ruby memory use grows through object retention, object creation hotspots, and heap growth, and shows when freezing or in-place changes can cut allocations and speed code up.
Simple and Clean Code vs. Performance
The article argues that simple, clean code should be the default. It separates efficiency from performance, says most code is not a bottleneck, and recommends profiling before sacrificing readability.
Coding for SSDs – Part 6: A Summary
The article summarizes SSD fundamentals, controller behavior, access patterns, and system optimizations programmers should consider to reduce write amplification, improve throughput, and avoid common performance pitfalls.
Client-side MVC's Major Bug
Tim Kadlec argues that client-side MVC frameworks often become the main performance bottleneck, especially on first load, and that they need server-side rendering to avoid hurting reach and stability.
Working Together, Sitting Apart
The article argues that remote collaboration succeeds when teams define process, responsibilities, and performance explicitly before starting work, and keep those agreements current through regular review.
Twitter muda de Ruby para Java. Ruby é 3x mais lento que Java.
O texto critica a leitura apressada de um caso do Twitter como prova geral contra Ruby. Argumenta que a troca para Java refletiu arquitetura, débito técnico e escala, não uma lei universal de performance.
Three things you should never put in your database
The article argues that databases should not store files, ephemeral data, or production logs, because these uses slow reads and writes, bloat backups, and waste resources better handled by other tools.
Getting to Know Pluck and Select
The post compares `pluck` and `select` in ActiveRecord, showing that `pluck` avoids model instantiation overhead, is faster for raw values, and `select` still matters when you need model objects and methods.
JavaScript: o que fazer e aprender para se tornar um desenvolvedor melhor?
O artigo indica caminhos para estudar JavaScript: aprender a linguagem, entender escopo, closures, eventos, protótipos, performance, debug e acompanhar a especificação ECMAScript.
Writing Fast, Memory-Efficient JavaScript
The article explains how V8 and garbage collection affect JavaScript performance, then gives practical rules for objects, arrays, closures, timers, DOM work, benchmarking, profiling, and leak detection.
Melhorando o desempenho de aplicativos .NET - Parte 07
O texto reúne práticas para usar chamadas assíncronas em .NET, destacando quando elas ajudam na responsividade do cliente ou no paralelismo no servidor, e quando só acrescentam bloqueio e complexidade.
Responsive Web Design – Adaptação vs Otimização
O texto defende que a escolha entre site responsivo e versão específica depende do projeto, do conteúdo e da experiência que se quer entregar, incluindo performance, design e UX.
Forgotten Rails features: HTTP Streaming
The post explains how Rails HTTP streaming sends the response in chunks, can make pages feel faster, and requires changes to render calls, templates, and server setup.
We're Doing It Wrong
The page explains how Array#sort behaves across browsers, why stable sorting and locale-aware string comparison matter, and how mapping values first can reduce comparison cost.