Tagged articles
enums
34 articles · Page 1 of 1
Node.js 26 LTS introduces direct execution of TypeScript files by stripping type annotations at runtime, preserving line numbers for debugging, while type checking remains a separate compile-time step; enums, decorators, and JSX are not supported.
JSXNode.jsNode.js 26
0 likes · 3 min read

This comprehensive tutorial covers Java fundamentals including program structure, variables, data types, operators, control flow, arrays, methods, object-oriented programming, exception handling, generics, collections, and practical examples for beginners.
DebuggingGenericsI/O
0 likes · 47 min read

This article explains how to replace repetitive try‑catch blocks in Java Spring applications with a unified exception handling strategy that leverages @ControllerAdvice, custom enums, and assertion utilities, providing clean, maintainable code, internationalized error messages, and consistent response structures for both business and system errors.
BackendException HandlingJava
0 likes · 21 min read

The article examines the heated community debate over a potential "Go 2" that adds many foreign features, contrasting the language's original simplicity with desires for enums, null‑safety and error‑handling sugar, while reflecting on Go's evolution and design philosophy.
Gobackward compatibilityenums
0 likes · 12 min read

This guide covers Python's core numeric and string types—including ints, floats, complex numbers, booleans, and bytes—explains common pitfalls like floating‑point precision, demonstrates formatting options, shows how to use enums and SQLAlchemy for cleaner code, and offers practical advice for readable and efficient scripting.
Best PracticesDecimalFormatting
0 likes · 21 min read

This article explains how PHP 8.1 enums—both plain and backed—can be used to model task priorities, add type safety, serialize to databases, define custom methods, and integrate with notification senders, demonstrating clean architecture and design benefits for backend applications.
PHPbacked-enumsbackend-development
0 likes · 7 min read

This guide explains PHP 8's match expression, highlighting its strict comparison, return capabilities, and practical examples—including basic rewrites, conditional branches, enum integration, and a driver factory pattern—to help developers replace switch statements with more robust code.
Factory PatternPHPcode refactoring
0 likes · 5 min read

This article explains how to replace repetitive try‑catch blocks in Java backend development by using Spring's @ControllerAdvice for centralized exception handling, leveraging Assert assertions and custom enum‑based error codes to create clean, maintainable code and consistent API responses.
JavaSpringUnified Response
0 likes · 22 min read

This article shares practical Java backend development techniques, covering safe enum usage, RESTful API design guidelines, generic bean conversion via JSON, effective Stream API patterns, and comprehensive null‑checking and assertion strategies to improve code reliability and maintainability.
REST APIStreamassertions
0 likes · 13 min read

This article explains what Java enums are, why they are preferable to constants, demonstrates basic and custom enum definitions, shows how to compare, switch, and extend enums with properties, methods and constructors, and explores advanced uses such as EnumSet, EnumMap, Singleton and Strategy patterns, including Java 8 stream examples and JSON serialization.
EnumMapEnumSetJava
0 likes · 16 min read

This article introduces Java enums, explains their definition, basic usage such as declaring, accessing, and iterating values, demonstrates advanced features like adding fields, implementing interfaces, using them in switch statements, and shows how enums can implement design patterns such as Singleton and Strategy.
Backenddesign-patternsenums
0 likes · 6 min read

This article walks through a Java junior's code review, showing step‑by‑step how simple null‑checks evolve into constant definitions, static methods, enums, Optional usage, and finally strategy‑pattern implementations, illustrating both useful refactoring and the risk of over‑design.
Javacode-refactoringdesign-patterns
0 likes · 13 min read

This article explains why developers should replace class‑constant patterns with PHP enums, highlighting four benefits: the built‑in cases method, type hinting, enum‑specific methods, and the uniqueness of enum types that improve code safety and readability.
PHPbackend developmentcode
0 likes · 3 min read

This article explains how to replace repetitive try‑catch blocks in Spring applications with a clean, assertion‑based approach combined with @ControllerAdvice and enum‑driven error codes, providing a unified way to handle service‑layer, controller‑layer, and unknown exceptions while keeping responses consistent and internationalized.
@ControllerAdviceBackendJava
0 likes · 20 min read

The article explains how to replace repetitive try‑catch blocks in Java Spring applications with a unified exception handling mechanism that leverages @ControllerAdvice, custom BaseException, Assert utilities, and enum‑based error codes to produce consistent, environment‑aware error responses.
BackendExceptionHandlingJava
0 likes · 20 min read

This article explains how to replace repetitive try‑catch blocks in Spring Boot applications with a unified exception handling mechanism that leverages @ControllerAdvice, custom Assert utilities, and enum‑based error codes to produce clean, maintainable backend code.
BackendException HandlingJava
0 likes · 22 min read

This article explains how to implement a comprehensive unified exception handling mechanism in Spring Boot by using @ControllerAdvice, custom BaseException/BusinessException classes, enum‑based error codes, assertion utilities, and standardized response objects to simplify error management across controller and service layers.
Exception HandlingJavaMyBatis Plus
0 likes · 22 min read

This article introduces Rust to front‑end developers, covering its origins, safety‑focused design, key language features such as ownership and borrowing, core data types, structs, enums, and practical code examples to help readers grasp why Rust is worth learning.
Programming LanguageRustdata types
0 likes · 6 min read


21CTOFeb 12, 2022 · Backend Development
The article reports Alexa’s shutdown and TIOBE’s shift to Similarweb, highlights the February TIOBE Top‑20 rankings with Python, C and Java gains, and dives into PHP 8.1’s new features—including enums, read‑only properties, async support, serverless frameworks, and a thriving ecosystem.
8.1PHPRead‑only Properties
0 likes · 5 min read

The article outlines PHP 8.1’s major enhancements—including enums, readonly properties, advanced callable syntax, fibers, intersection types, never return type, final class constants, octal literals, and performance improvements—providing code comparisons that illustrate the new syntax and behavior.
8.1FibersPHP
0 likes · 9 min read

This article examines various Swift performance optimization techniques—including compilation speed improvements, memory allocation strategies, struct versus class trade‑offs, enum usage, collection handling, lazy sequences, bridge reduction, and function dispatch—providing practical code examples and analysis to help developers write faster, more efficient Swift code.
SWIFTcollectionscompilation
0 likes · 16 min read

This article introduces the ten most important new features of PHP 8.1—including enums, fibers, the never return type, readonly properties, final class constants, array_is_list(), fsync/fdatasync, string‑key array unpacking, the $_FILES full_path key, and the IntlDatePatternGenerator class—each explained with clear code examples.
BackendFibersFinal
0 likes · 15 min read

This article explains PHP 8.1’s native enum feature, covering basic enum definitions, typed properties, methods, backed enums, serialization, case listing, reflection, traits, and practical code examples to help backend developers adopt enums in their projects.
BackendPHPPHP8.1
0 likes · 6 min read

PHP 8.1 has entered the Alpha stage, introducing enums, Fibers, new hashing algorithms, improved resource handling, macOS‑specific PHP‑FPM enhancements, and performance optimizations, with a detailed schedule for subsequent Alpha, Beta, and final GA releases later this year.
FibersPHP8.1enums
0 likes · 3 min read

This article provides a comprehensive, English‑language summary of Joshua Bloch’s *Effective Java*, covering 90 practical rules and best‑practice solutions for object creation, immutability, concurrency, enums, API design, and many other core Java programming topics.
Best PracticesJavaenums
0 likes · 39 min read

PHP 8.1 is being developed with an Alpha release slated for June and a GA launch in November, introducing enums, new fsync/fdatasync functions, inheritance cache performance gains, Fiber support for async programming, and added xxHash and MurmurHash V3 hashing algorithms.
FibersPHP8.1enums
0 likes · 2 min read

This article discusses common pitfalls in Java code such as string and numeric matching, explains why using raw literals can cause bugs, and demonstrates how to improve readability and maintainability by employing enums, value conversion, and state‑machine patterns for backend development.
BackendBest PracticesCode Readability
0 likes · 8 min read

This article explains the concept of syntactic sugar in Java, covering generics, autoboxing/unboxing, enums, inner classes, variable‑length arguments, enhanced for‑loops, switch on strings, conditional compilation, assertions, try‑with‑resources, and string concatenation, with code examples and byte‑code analysis.
AutoboxingGenericsVarargs
0 likes · 17 min read

This guide introduces TypeScript, covering its definition, advantages, data types, enums, interfaces, classes, function definitions, parameter handling, overloads, and best practices, with code examples illustrating each concept for developers seeking to write safer, more maintainable JavaScript.
Frontend DevelopmentTypeScriptenums
0 likes · 12 min read

This article provides a thorough overview of TypeScript, covering its definition as a JavaScript superset, key advantages, built‑in data types, enum variations, interface capabilities, function declaration styles, parameter handling techniques, overloads, and practical code examples to illustrate each concept.
TypeScriptenumsfunctions
0 likes · 11 min read

This article explains what Java enums are, why they are useful, how to define simple and custom enum types, compare them safely, use them in switch statements, enrich them with fields, methods and constructors, and apply them in advanced scenarios such as EnumSet, EnumMap, Singleton and Strategy patterns, as well as Java 8 stream APIs and JSON serialization.
EnumMapEnumSetJava
0 likes · 17 min read

The article presents a toolbox of practical Java techniques—including using HashSet for fast duplicate detection, HashMap for building hierarchical structures, ThreadLocal for thread‑specific data, Pair and custom holder classes for multiple return values, enum definitions, union‑style classes, and generic and wildcard patterns—to streamline everyday coding tasks.
JavaThreadLocalcollections
0 likes · 22 min read

The article explains Java's syntactic sugar—including generics with type erasure, autoboxing/unboxing, varargs, enhanced for‑loops, inner classes, and enums—showing how each feature simplifies code while being transformed into standard bytecode during compilation.
AutoboxingEnhanced For LoopGenerics
0 likes · 8 min read

This article presents four practical Java optimization strategies—targeted performance tuning, replacing primitive constants with enums, correctly overriding the equals() method, and increasing the use of polymorphism—to improve system efficiency and code readability while highlighting when each technique should be applied.
Javaenumsequals
0 likes · 18 min read
