Bilingual

A Fake Shell for Pangenomics
a month ago
- FlatGFA is an efficient pangenomics toolkit with a zero-copy data format, making it identical in memory and on disk, which allows skipping serialization/deserialization and using mmap for fast file opening.
- To promote adoption among genomicists, the author explored CLI and Rust API options but found them limited; instead, they built Flash, a fake shell that uses shell syntax to run workflows while internally optimizing with a vectorized interpreter and avoiding I/O overhead.
- Flash translates shell scripts into an instruction-based IR, special-cases pangenomic tools to call Rust functions directly, supports mixed resource types (e.g., in-memory stores and files), and implements optimizations like deduplication and format switching for speedups up to 28× compared to traditional shells.
SQLite improving performance with pre-sort
a month ago
- UUID4's randomness slows down insert speeds, similar to random data like 20-byte session tokens, due to B+ Tree page thrashing.
- Presorting random data before insertion improves SQLite performance by 2-3x by leveraging sequential writes.
- A custom byte comparison function converts first 8 bytes of BLOBs to unsigned longs for fast sorting, matching SQLite's memcmp().
- Batching data allows optimizations like presorting, making it useful for unordered data in performance-critical scenarios.
wolfSSL vs. MbedTLS
23 days ago
- wolfCrypt consistently outperforms MbedTLS across multiple platforms (x86_64, ARMv8-A Cortex-A76, Cortex-M33, RISC-V), with speed advantages ranging from 1.4x to 53x, especially in public-key operations.
- wolfCrypt includes extensive hand-written assembly optimizations for hot paths on x86, ARM, and RISC-V, while MbedTLS relies more on portable C, leading to significant performance gaps.
- wolfSSL provides a complete post-quantum CNSA 2.0 suite (ML-KEM, ML-DSA, LMS, XMSS, SLH-DSA) and additional algorithms (e.g., EdDSA, AES-SIV) that MbedTLS does not support.
- wolfSSL offers broader portability, certifications (FIPS 140-3, DO-178C DAL-A, ISO 26262 ASIL D), commercial support, and features like OpenSSL compatibility and TLS inspection, unlike MbedTLS.
- wolfCrypt integrates with the Arm PSA Crypto API via wolfPSA, allowing drop-in replacement in PSA-based designs without rewriting applications, while maintaining performance and algorithm coverage.
Zig: Package Management Moved from Compiler to Build System
20 days ago
- Package management functionality moved from compiler to build system for flexibility and safety improvements.
- SPIR-V backend progress includes new builtins, execution modes, multi-threaded codegen, and object file linking.
- Redefined @bitCast semantics to use logical bit layout, improving cross-platform consistency.
- ELF linker improvements enable incremental compilation with external libraries, including LLVM and LLD.
- Build system rework separates configurer and maker processes, speeding up builds and enabling cached configurations.
- Package management workflow enhancements include local zig-pkg directory and --fork flag for dependency overrides.
- Windows std.Io bypasses kernel32.dll for direct ntdll calls, improving performance and reliability.
- Zig libc project replaces C source files with Zig wrappers, reducing code and enabling optimizations.
- New std.Io.Evented implementations (io_uring and GCD) enable experimental async I/O with fiber-based coroutines.
- Type resolution redesign improves laziness, dependency loop error messages, and incremental compilation performance.
Show HN: Simulate API traffic directly from your IDE with .http files
20 days ago
- Modern architecture designed for massive scalability, surpassing legacy tools that rely on heavy OS threads.
- Utilizes a pure-Go lock-free Actor Model to isolate connections into ultra-lightweight Goroutines.
- Achieves over 30,000 RPS with zero-garbage overhead (0 allocs/op) in a single instance.
Astro 7.0
15 days ago
- Astro 7 release focuses on performance improvements, achieving 15-61% faster builds.
- Key upgrades include a Rust-based .astro compiler, Rust-powered Markdown/MDX pipeline via Sätteri, and a queue-based rendering engine.
- Integration with Vite 8 and its Rolldown bundler enhances build speeds, with no configuration changes for most projects.
- Advanced Routing introduced with src/fetch.ts for full control over Astro’s request pipeline, compatible with Hono middleware.
- Route caching is stabilized, with experimental CDN cache providers for Netlify, Vercel, and Cloudflare.
- AI enhancements include background dev server mode and JSON logging to support AI coding agents and structured logs.
- Benchmarks show significant build time reductions across various sites, with the largest gains on Markdown-heavy pages.
The Science Behind Why Soccer Players the 26 World Cup Are Cutting Their Socks
15 days ago
- Players cut holes in soccer socks to relieve discomfort from tightness, though no scientific evidence supports performance benefits.
- Compression socks provide support, moisture management, and stability; research shows they can limit muscle inflammation when properly fitted.
- The practice is driven by personal comfort perception, which can boost confidence, making it a psychological rather than physiological phenomenon.
Performance Optimized Statically Typed Python
15 days ago
- POST Python is a performance optimized, statically typed subset of Python that is compilable.
- It runs unmodified under CPython and can be compiled to native code without a Python runtime.
- Functions can be interpreted as Python, compiled to native C kernels, or turned into numpy.ufuncs.
- It emphasizes a normative specification over informal subsets, with conformance profiles for tools.
- The reference compiler rejects unsupported semantics clearly, avoiding silent behavior changes.
- PostSciPy is rebuilding SciPy as POST Python libraries to discover language gaps and drive development.
- Current status includes structural checking, scalar kernels, vectorization, cross-module linking, and CPython extensions.
- Specification is a draft v0.2, and interfaces are subject to change.
TypeScript 7
14 days ago
- TypeScript 7 is a native port built in Go, offering 8-12x speed improvements on full builds and reduced memory usage.
- It introduces parallelization with flags like --checkers and --builders, and a new --singleThreaded flag for debugging or limited environments.
- TypeScript 7 includes a rebuilt --watch mode based on Parcel's file watcher, improving cross-platform efficiency.
- Editor support is enhanced via LSP, with faster load times, auto-completions, and diagnostics in VS Code, Visual Studio, and others.
- Compatibility with TypeScript 6.0 is maintained via the @typescript/typescript6 package for side-by-side usage.
- JavaScript support is reworked for consistency with TypeScript files, removing some legacy JSDoc patterns.
- Template literal types now preserve Unicode code points, treating characters like emojis as single units.
- Notable defaults changed in TypeScript 7 include strict mode being true, module defaulting to esnext, and types defaulting to an empty array.
- Workflows using Vue, MDX, Astro, Svelte, or Angular may not yet leverage TypeScript 7 due to lack of stable API, but CLI usage is possible.
- The TypeScript team plans to return to feature work, with TypeScript 7.1 expected to introduce a new API and further improvements.
Cargo-nextest: 3x faster than cargo test, per-test isolation, first-class CI
17 days 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.
EF Core 11 makes your split queries faster
18 days 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.
Litert.js, Google's High Performance Web AI Inference
10 days 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.
Are you telling me a readonly property is wrecking my performance?
13 days 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.
SQLite Is All You Need
8 days 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.
FFmpeg gets 1.372x faster RGB24-to-RGBA conversion with AVX-512
3 days 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.
Some more things about Django I've been enjoying
8 hours 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.
Everyone Should Know SIMD
4 hours 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.

Hasty Briefsbeta

#performance

A Fake Shell for Pangenomics

SQLite improving performance with pre-sort

wolfSSL vs. MbedTLS

Zig: Package Management Moved from Compiler to Build System

Show HN: Simulate API traffic directly from your IDE with .http files

Astro 7.0

The Science Behind Why Soccer Players the 26 World Cup Are Cutting Their Socks

Performance Optimized Statically Typed Python

TypeScript 7

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

EF Core 11 makes your split queries faster

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

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

SQLite Is All You Need

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

Some more things about Django I've been enjoying

Everyone Should Know SIMD