Hasty Briefsbeta

All tags

performance

29 stories total

Bilingual

You might want to build your WebApp in Canvas instead of HTML
2 months ago
- Canvas is used by large companies like Google and Microsoft for performance-critical web apps such as Google Docs, Sheets, Canva, Miro, and Hivekit.
- Canvas provides a blank drawing area using a JavaScript API, offering speed, control, consistency, and portability at the cost of losing DOM features.
- Reasons to use Canvas include faster performance (less browser parsing), full control over rendering, consistent output across devices, and easy integration with other frameworks.
- Reasons against Canvas include missing built-in features like text input, accessibility, and responsive layouts; DOM is better for most web apps.
- Canvas is best for apps with many absolutely positioned elements, irregular shapes, zoomable/pannable workspaces, or a strong internal model.
- Key implementation tips include managing render scheduling, layering multiple Canvas elements, separating styles, handling device pixel ratio, central coordinate translation, maintaining bounding box indices, and managing event handler lifecycles.
- Canvas is suitable when the interface behaves like a scene rather than a document; choose it for spatial workspace apps, not as a general HTML replacement.
Octane – React's programming model, compiled
2 months ago
- Octane is a compiled frontend framework that removes the need for rules of hooks and dependency arrays, allowing hooks to be placed in conditions or early returns.
- It compiles templates to direct DOM writes and keyed @for lists for efficient updates, and supports .tsx files for gradual adoption.
- Octane maintains compatibility with React components, hooks, Suspense, context, portals, transitions, actions, controlled forms, and SSR, enabling migration one component at a time.
- Signals are optional; Octane keeps components as plain functions that read top-to-bottom, with the compiler handling performance optimization.
- The framework significantly outperforms React in most benchmarks, often being 2-3x faster, and is competitive with other modern frameworks like Svelte, Solid, and Vue Vapor.
- It includes a CLI tool, octane doctor, for diagnosing issues, and supports integration with existing React apps via OctaneCompat islands.
Cyberscript
2 months ago
- Easy to learn with dynamic and static typing options.
- Concurrency supported via fibers (co-routines).
- Memory safe by design.
- FFI and embeddable via libcyber and C-ABI compatibility.
- Fast VM and JIT compiler, cross-platform.
- Optional static typing for performance.
- Use cases include fast scripting and performance-critical tasks.
- Interop allows embedding into applications and generating bindings automatically.
- Open source project welcoming contributions and support.
Pgtestdb's template cloning approach to testing is fast
2 months ago
- pgtestdb is a Go/Postgres testing package that leverages Postgres template databases for fast test database cloning.
- Template database cloning is faster than migrating a test database from scratch and lighter than Docker-based approaches.
- River's test suite uses a schema-based isolation method that is slower than test transactions but has advantages like lighter weight than databases.
- Performance comparison showed similar setup times (~100ms) for both pgtestdb clone and create+migrate schema methods.
- River's schema-based approach achieved 3.5x faster overall wall time due to test schema pooling and reuse, which avoids re-migration.
- Schema reuse can be applied to pgtestdb as well, potentially reducing test setup to 10-20ms for large test suites.
- The author recommends pgtestdb for end-to-end testing but will keep River's schema-based method due to its incidental verification of schema configuration.
Interconverting std::function with copyable_function
2 months ago
- C++11's std::function has design flaws: bloated API, const operator() despite mutable callables, and exception handling preventing noexcept.
- C++26 introduces std::copyable_function to fix these issues while retaining some suboptimal designs like implicit conversions and nullptr assignability.
- copyable_function and function are interconvertible, but naive implementations can create a 'linked list' of callables, degrading performance over time.
- libstdc++ currently shows O(n) call overhead as wrappers nest, while Microsoft STL avoids this issue and libc++ hasn't implemented yet.
- Mixing copyable_function and function in brown-field code can cause logical memory leaks and slower execution, especially with repeated conversions.
- Recommendation: avoid mixing both types in the same codebase; write custom type-erased callables for new code or consistently use one type.
How Do I Profile eBPF Code?
2 months ago
- Measure performance impact of eBPF code using a simple C test harness that times file open operations via syscall(SYS_openat) under warm cache conditions.
- Enable BPF JIT and expose symbols via sysctl commands so perf can resolve eBPF program names instead of unknown addresses.
- Run baseline test without eBPF, then profile with eBPF using perf record with options like taskset, chrt, frame pointers, and 997 samples per second.
- Analyze perf report to identify bottlenecks, such as the bpf_lsm_file_open hook and its tail calls, which can dominate overhead.
- Focus on the profiling method; actual overhead depends on the eBPF hook's implementation and can be optimized via caching or better algorithms.
After Credentials
2 months ago
- The US has shifted from credential-based to performance-based evaluation over the past 25 years, unlike South Korea where university entrance exams still dominate.
- Credentials originated as an improvement over bribery and family influence, but they are imperfect and lead to cram schools that exploit the system.
- Parents naturally try to use their wealth or power to give their children an advantage, which society must counteract to ensure meritocracy.
- Improving credentials is a long-term solution, but a more effective approach is to reduce the importance of credentials by measuring actual performance.
- Small organizations and startups evaluate performance directly, making credentials less relevant, and this trend is spreading through the economy.
- The rise of market-based pay for young workers, exemplified by yuppies and startups, has driven the shift from seniority to performance-based rewards.
- Encouraging an economy of smaller units and measuring performance is a better way to prevent intergenerational power transmission than relying on credentials alone.
Entropic Thoughts
2 months ago
- METR research shows LLMs pass tests more often than they produce mergeable code, with a stricter success criterion (maintainer approval) revealing much lower performance.
- The 50% success horizon dropped from 50 minutes to 8 minutes when using the more stringent criterion.
- Analysis of merge rates over time suggests no significant improvement since early 2025, despite a possible step-up in late 2024.
- Brier score comparisons indicate that a piecewise constant or constant function predicts merge rates better than a gentle upward slope, contradicting claims of steady improvement.
- The author questions the gap between perceived buzz and actual performance, noting that similar claims of progress in 2025 were not borne out by data.
JAX: commitment issues
2 months ago
- Creating an array with `jax.default_device` does not commit it to that device; JAX may move it elsewhere.
- Simple array lookups (e.g., `array[0]`) on an uncommitted CPU array can take over 5 seconds due to implicit GPU transfers.
- Explicitly committing an array with `jax.device_put(array, cpu0)` reduces lookup times dramatically (e.g., from 1.2s to <0.0002s).
- The issue stems from JAX moving the entire uncommitted array to the GPU for each lookup, causing severe performance degradation.
- For CPU-bound data like training datasets, always use `device_put` to nail arrays to the desired device and avoid hidden GPU overhead.
Regular expression speed and error rates
2 months ago
- Regex for ICD-10 codes: [A-TV-Z][0-9][0-9AB]\.?[0-9A-TV-Z]{0,4} excludes U as first letter but allows it later.
- Speed: Regex search (egrep) took 18 ms on an 800 KB file, while list search (grep) took 386 seconds—five orders of magnitude faster.
- Error rates: Initially zero false negatives, but later 3 codes (U070, U071, U099) became false negatives due to standard changes; regex is more future-proof than an exhaustive list.
- False positive rate depends on context: low in medical notes but extremely high in random alphanumeric text (99.9986% of matches are false).
- The optional period may appear even without following alphanumeric characters, though not in the standard—practical usage can vary.
Before You memo() — overreacted
2 months ago
- Before applying memo() or useMemo(), first try to split components that change from those that don't.
- Solution 1: Move state down by extracting the part of the UI that depends on the state into its own component.
- Solution 2: Lift content up by passing unchanged parts (e.g., as children prop) to the state-dependent component to prevent re-rendering.
- These techniques improve code clarity and data flow, with performance as a bonus.
- They complement memo() and useMemo()—use the Profiler and memo() only when these simpler methods aren't enough.
Claude Opus 5
2 months ago
- Claude Opus 5 is a new model from Anthropic, offering near-frontier intelligence at half the price of Claude Fable 5.
- It achieves state-of-the-art results on coding and knowledge work benchmarks like Frontier-Bench and GDPval-AA, though lags behind Mythos 5 on cybersecurity.
- Opus 5 is designed for everyday use, with improved efficiency and cost-effectiveness compared to its predecessor Opus 4.8.
- It excels in software engineering, knowledge work, and scientific research tasks, often surpassing other models at lower cost.
- The model demonstrates strong agency and thoroughness, such as writing its own computer vision pipeline to solve a task and fixing bugs missed by human patches.
- Early-access customers report significant improvements in areas like financial modeling, legal work, code review, and agentic workflows.
- Opus 5 is highly aligned with safety principles, showing low rates of deceptive behavior and susceptibility to misuse.
- It includes safeguards for cybersecurity and biology, with automatic fallbacks and a Cyber Verification Program for enterprises.
- Opus 5 is available today at $5 per million input tokens and $25 per million output tokens, with a Fast mode option.
Everyone Should Know SIMD
2 months ago
- SIMD enables CPUs to process multiple values in parallel, often used to accelerate loops over large data.
- Common SIMD code follows five steps: broadcast constants, loop over vector-width chunks, perform parallel operations, reduce results, and handle remainder with a scalar tail.
- A real example (searching for control characters) shows how a scalar loop can be vectorized, achieving 4x-16x speedup.
- Compilers can auto-vectorize simple loops but are often limited; manual SIMD provides explicit and predictable performance.
- Every developer should understand SIMD basics and recognize opportunities for vectorization without fear.
Some more things about Django I've been enjoying
2 months ago
- The author is learning to build websites using a 2010-style backend approach with Django, focusing on SQL databases and server-rendered HTML.
- Key Django features enjoyed include query builders for readable SQL-like filters, template filters for URL formatting and date handling, the querystring filter for dynamic links, and automatic database migrations.
- The author prefers function-based views over class-based inheritance for code organization, finding inheritance less straightforward in Python.
- Performance concerns include handling bursts of traffic, caching strategies, and template optimization; enabling cached template loaders significantly improved request handling from 2-3 to 12 requests per second.
- The author finds Django's settings file confusing and notes that performance issues often stem from misconfiguration (like disabled template caching) rather than slow database queries.
FFmpeg gets 1.372x faster RGB24-to-RGBA conversion with AVX-512
2 months ago
- FFmpeg gets AVX-512 optimization for 1.372x faster pixel format conversion.
- Developer Niklas Haas used AVX-512's VPERMB instructions in libswscale for better video scaling.
- Optimization benefits AMD Zen 4+ and Intel Xeon/AVX-512 CPUs in RGB24 to RGBA conversion.
SQLite Is All You Need
2 months ago
- SQLite with WAL mode can handle a social network of 50,000 users, 1 million posts, and millions of interactions in a single 343MB file.
- The heaviest query, a timeline join with counts, served 3,654 requests per second on a laptop, equivalent to 315 million requests per day.
- WAL mode eliminates SQLITE_BUSY errors and allows concurrent reads and writes, unlike the older rollback journal which causes significant slowdowns.
- Limitations include: reads scale poorly with concurrent writes due to cache invalidation, only one global writer, no built-in failover, and it's unsuitable for high-write contention or extensive analytics.
- On a cheap VPS, a single core can still serve over 110 million timeline requests per day, making SQLite feasible for most applications.
- Recommendations: use STRICT tables for type safety, prioritize single-core speed and enough RAM for the database, avoid network storage, and consider dedicated cores for better p99 latency.
- Development benefits include: local database as a file, easy testing with isolated databases, simple deployments, and minimal operational overhead.
- Backups are straightforward file copies, and tools like Litestream enable continuous replication.
- Bun with bun:sqlite performed better on lightweight endpoints but worse on heavy queries compared to Node with better-sqlite3, emphasizing the need to measure specific workloads.
- The article argues that premature scaling with complex databases like Postgres is often unnecessary; SQLite suffices for most projects until clear scaling signals emerge.
Are you telling me a readonly property is wrecking my performance?
2 months ago
- A performance issue was investigated in Letta Desktop where increasing usage slowed the product, initially suspected to be due to unoptimized code.
- The root cause was found to be the use of 'el.scrollTop = el.scrollHeight;' to scroll the UI on new messages, assuming scrollHeight was a static, performant readonly property.
- In reality, scrollHeight is dynamic and recalculated on access, causing slowdowns when frequently updated during high message streams.
- The chromium implementation shows scrollHeight triggers layout updates, making it non-performant for frequent use.
- A solution was to use a very large number instead of calculating scrollHeight precisely, relying on bounding behavior.
- Key advice: Readonly properties can be dynamic and impact performance, especially when obvious changes occur.
- Lessons include questioning assumptions about property performance and optimizing UI interactions.
Litert.js, Google's High Performance Web AI Inference
2 months ago
- LiteRT.js is a JavaScript binding of LiteRT for running AI models directly in web browsers, enabling local, on-device inference for enhanced privacy, zero server costs, and ultra-low latency.
- It offers improved performance over prior solutions like TensorFlow.js by leveraging WebAssembly and hardware acceleration through XNNPACK for CPU, ML Drift for GPU, and WebNN for NPUs.
- Key features include PyTorch model conversion via LiteRT Torch, tailored quantization with AI Edge Quantizer for size and performance gains, and support for multiple hardware backends (CPU, GPU, NPU).
- Benchmarks show LiteRT.js outperforms other web runtimes by up to 3x on CPU and GPU, with GPU/NPU acceleration providing 5-60x speedups for real-time applications like object tracking and audio processing.
- Demo implementations include Depth Anything for real-time 3D point clouds from webcam feeds and Real-ESRGAN for 4x image upscaling, with official export support for Ultralytics YOLO models.
- Integration is straightforward with a streamlined JavaScript API for loading, compiling, and running .tflite models, and future development focuses on WebNN integration and generative AI support.
EF Core 11 makes your split queries faster
3 months ago
- EF Core 11 improves performance of split queries by pruning unnecessary reference navigations from collection queries.
- In EF Core 10, split queries with multiple reference navigations included extra JOINs and ORDER BY columns in collection queries, causing inefficiencies.
- EF Core 11 removes these unnecessary joins, resulting in faster queries with reduced database work and fewer allocations.
- Benchmarks show a decrease in execution time and memory usage when using split queries in EF Core 11 compared to EF Core 10.
Cargo-nextest: 3x faster than cargo test, per-test isolation, first-class CI
3 months ago
- Clean UI for clear test pass/fail status.
- Up to 3x faster than cargo test via modern execution.
- Advanced selection using expressions for filtering.
- Detects and terminates slow tests; supports stress testing.
- Customizable test settings: retry, mark heavy, run serially.
- Records runs, replays CI, reruns failures, exports Perfetto traces.
- CI-friendly: archives, partitions, exports JUnit, uses profiles.
- Setup scripts pre-test for databases, services, fixtures.
- Ecosystem tools: coverage, mutation testing, debuggers, probes.
- Cross-platform: Linux, Mac, Windows, Unix; binary or source.
- Open source, trusted from indie projects to large companies.
- Infrastructure-grade reliability with attention to detail.

firstprev0next

performance

You might want to build your WebApp in Canvas instead of HTML

Octane – React's programming model, compiled

Cyberscript

Pgtestdb's template cloning approach to testing is fast

Interconverting std::function with copyable_function

How Do I Profile eBPF Code?

After Credentials

Entropic Thoughts

JAX: commitment issues

Regular expression speed and error rates

Before You memo() — overreacted

Claude Opus 5

Everyone Should Know SIMD

Some more things about Django I've been enjoying

FFmpeg gets 1.372x faster RGB24-to-RGBA conversion with AVX-512

SQLite Is All You Need

Are you telling me a readonly property is wrecking my performance?

Litert.js, Google's High Performance Web AI Inference

EF Core 11 makes your split queries faster

Cargo-nextest: 3x faster than cargo test, per-test isolation, first-class CI