Tagged articles
compile‑time
32 articles · Page 1 of 1
The article explains that a false if constexpr condition does not magically erase the other branch; the compiler still performs semantic checks on non‑dependent code, and the real difference lies in how SFINAE discards whole overload candidates while if constexpr only discards statements after overload resolution.
C++GCCSFINAE
0 likes · 13 min read

Feat 2.3.0 introduces compile‑time generated interceptors that replace Spring‑style runtime proxies, showing how AOT weaving eliminates reflection overhead, reduces startup cost, and offers a clean stack trace, while outlining the trade‑offs, limitations, and practical usage guidelines for Java developers.
AOTBackendFeat
0 likes · 9 min read

Feat 2.2.0 launches a Java web framework that mimics Spring Boot's developer experience while discarding legacy Servlet APIs, introducing compile‑time code generation and a smart‑socket engine that delivers roughly double the throughput of Vert.x with sub‑millisecond latency.
JavaServletSpring Boot
0 likes · 7 min read

The article explores Feat's attempt to build a reflection‑free ORM that preserves MyBatis‑like developer experience by moving all mapping work to compile time, discusses the challenges posed by Java's AOT shift, and argues why such an experiment is both risky and worthwhile.
AOTGraalVMJava
0 likes · 6 min read

This article explains the fundamental differences between compile-time and run-time constants in Java, covering their definitions, required modifiers, allowed data types, initialization rules, JVM storage behavior, class‑initialization effects, constant‑folding optimizations, practical code examples, common pitfalls, and guidelines for choosing the appropriate constant type in production code.
Best PracticesJVMJava
0 likes · 21 min read

After five years of daily Rust development, the author outlines persistent challenges such as long compile times, restrictive borrow‑checking, cumbersome async patterns, boilerplate from the orphan rule, and their impact on team productivity, while acknowledging Rust's safety and performance benefits.
Rustasyncborrow checker
0 likes · 7 min read

After five years of using Rust for backend services, CLI tools, and embedded systems, the author outlines persistent frustrations such as long compile times in large workspaces, cumbersome borrow‑checker constraints, awkward async ergonomics, excessive boilerplate from the orphan rule, and the impact of these issues on team productivity, while acknowledging Rust’s safety and performance benefits.
Rustasyncborrow checker
0 likes · 7 min read

This article explains how C++ template metaprogramming (TMP) and SFINAE let developers move calculations and type checks to compile time, providing zero runtime cost, and demonstrates practical techniques with clear code examples and modern language features up to C++20.
C++C++20SFINAE
0 likes · 23 min read

Template Metaprogramming (TMP) leverages C++ templates to perform compile‑time calculations and code generation, offering zero‑cost abstractions, type safety, and performance gains, with examples like compile‑time factorials and type‑trait utilities, while modern C++ features such as constexpr and variable templates simplify its usage.
C++Zero-cost abstractioncompile‑time
0 likes · 10 min read

This article explains the differences between C++ const and constexpr, using a kettle analogy, detailed code examples, and practical guidelines to help developers choose the right keyword for compile‑time or runtime constants, improve performance, and write safer code.
Best PracticesC++Runtime
0 likes · 8 min read

This article explains the distinct roles of const and constexpr in C++, covering their usage with variables, pointers, function parameters, and class members, comparing compile‑time and run‑time behaviors, and offering practical interview strategies and code examples for developers.
C++Interviewcompile‑time
0 likes · 19 min read

This article explains how to create a custom insert annotation and an annotation processor in Java to automatically inject the jar version into component constants at compile time, enabling Prometheus monitoring without manual version updates.
GradlePrometheusVersioning
0 likes · 7 min read

This article explains how to create a custom compile‑time annotation processor that automatically injects the current JAR version into Java component constants, eliminating manual updates and enabling Prometheus monitoring of version usage across internal libraries.
Annotation ProcessingGradlePrometheus
0 likes · 7 min read

This article explains how to create a compile‑time annotation processor that automatically injects the JAR version into a static constant, enabling Prometheus to monitor version usage without manual updates, and demonstrates the implementation with Lombok‑style code examples.
Annotation ProcessorGradleJava
0 likes · 8 min read

This article demonstrates how to create a custom compile‑time annotation processor that automatically injects the JAR version into Java constants, enabling Prometheus monitoring of component versions without manual updates, and walks through the full implementation, registration, and testing steps.
Annotation ProcessingGradlePrometheus
0 likes · 8 min read

This article demonstrates how to create a custom insertable annotation processor in Java that automatically injects the jar version into component constants at compile time, enabling Prometheus monitoring of version usage without manual updates.
Annotation ProcessingGradleLombok
0 likes · 8 min read

This article explains how to create a custom insertable annotation processor in Java that automatically injects the jar version into component constants during the Gradle build, eliminating manual updates and enabling version monitoring via Prometheus.
ASTAnnotation ProcessingGradle
0 likes · 8 min read

This article demonstrates how to create a compile‑time insertion annotation processor in Java that automatically injects the current jar version into static constants of shared components, eliminating manual updates and enabling Prometheus monitoring of version usage across the organization.
Annotation ProcessingGradleVersion Injection
0 likes · 8 min read

This article analyses how modern frontend view frameworks such as Solid, Svelte, Qwik, React, Vue and Angular are converging on a solidified programming paradigm while competing through fine‑grained rendering, reactive data, developer tooling, compilation strategies and the push to reduce JavaScript for better first‑page performance.
FrameworksReactivityRendering
0 likes · 14 min read

This article demonstrates how to create a custom compile‑time annotation processor that automatically injects the jar version into Java component constants, enabling Prometheus monitoring of version usage without manual updates.
Annotation ProcessingLombokcode-generation
0 likes · 8 min read

This article explains what Lombok is, how it uses compile‑time annotations and the Java Annotation Processing Tool (APT) to automatically generate getters, setters, constructors and other boilerplate code, and provides step‑by‑step examples of defining custom annotations, processors, and compiling them to produce new classes.
Annotation ProcessingJavaLombok
0 likes · 12 min read

This article explains how Lombok uses compile‑time annotations and the Java Annotation Processing Tool (APT) to automatically generate boilerplate code such as getters, setters, and constructors, and provides step‑by‑step examples of defining custom annotations, processors, and compiling them.
Annotation ProcessingJavaLombok
0 likes · 11 min read

This article explains how Java annotations can be leveraged not only at runtime via reflection but also during compilation by creating custom annotation processors, illustrating the definition of an annotation, implementing a processor, configuring SPI, and demonstrating error handling with Maven.
Annotation ProcessorAnnotationsJava
0 likes · 5 min read

This article explains Java's String length limits, detailing how the underlying char[] array, int return type, and JVM constant‑pool specifications together define both the theoretical 2^31‑1 character maximum and the compile‑time literal limit of 65,534 characters.
Constant PoolJVMJava
0 likes · 8 min read

This article explores the evolution of C++ templates, explains the purpose and syntax of concepts, demonstrates how they replace SFINAE and enable_if with clearer compile‑time checks, and shows practical ways to define and use concepts for safer generic programming.
C++C++20Concepts
0 likes · 10 min read


ByteFEOct 19, 2021 · Frontend Development
This article explains how to perform high‑precision addition of arbitrarily large numbers entirely at compile time using TypeScript's type system, converting strings to digit arrays, adding digits with lookup tables, handling carries, and finally converting the result back to a string.
AdditionGeneric TypesTypeScript
0 likes · 9 min read

This article explains the theoretical and practical limits of Java String length, detailing how strings are stored as char arrays, the impact of the JVM constant‑pool specification (u2 index limit of 65534), and how runtime concatenation can exceed compile‑time restrictions.
Constant PoolJVMJava
0 likes · 8 min read

This article explores the theoretical and practical limits of Java String length, analyzing JDK source code, integer ranges, JVM constant pool constraints, and runtime memory considerations to reveal why the maximum size is 2^31‑1 characters (≈4 GB) at runtime but only 65 534 characters at compile time.
JVMJavaLength Limit
0 likes · 8 min read

This article examines the evolution of WeChat mini‑programs, compares native syntax with progressive enhancement, compile‑time conversion and runtime frameworks, and offers guidance on selecting the most suitable approach based on performance, syntax flexibility, and business needs.
RAXRuntimeTaRO
0 likes · 16 min read

This article explains Java annotation fundamentals, explores built‑in meta‑annotations, demonstrates how to create compile‑time and runtime custom annotations, and shows how to integrate them with Spring Boot AOP for automatic logging and request handling.
AOPAnnotationsJava
0 likes · 8 min read

This article explains the design and implementation of Permissions4M, an Android library that uses compile‑time annotations to simplify runtime permission handling, covering the pre‑compilation, compilation, and post‑compilation stages, module structure, key code snippets, and usage patterns.
AndroidAnnotation ProcessingJava
0 likes · 18 min read

This article explains key Java concepts such as compile‑time constant folding, the distinction between compile‑time and runtime calculations, method overloading versus overriding, generics type erasure, annotations, exception handling, and aspect‑oriented programming, while illustrating each topic with clear code examples.
AOPGenericsJava
0 likes · 12 min read
