Tagged articles
1248 articles
Page 8 of 13
IT Architects Alliance
IT Architects Alliance
Nov 21, 2021 · R&D Management

Mastering Software Architecture: From Basics to Evolution

This comprehensive guide explains the essence of software architecture, its layers and classifications, architectural levels, strategic versus tactical design, evolution from monoliths to micro‑services, common pitfalls, and key metrics for evaluating a sound architecture.

Architecture PatternsDistributed SystemsMicroservices
0 likes · 22 min read
Mastering Software Architecture: From Basics to Evolution
21CTO
21CTO
Nov 16, 2021 · Fundamentals

Why Code Review Matters: Mastering Design Principles for Cleaner Code

This article explains why developers and leaders must practice thorough code reviews, outlines common pitfalls such as duplicated code and premature optimization, and shares concrete Go examples and timeless engineering principles—like KISS, composition over inheritance, and transparent design—to help teams build maintainable, high‑quality software.

Code reviewbest practicesdesign principles
0 likes · 42 min read
Why Code Review Matters: Mastering Design Principles for Cleaner Code
Open Source Linux
Open Source Linux
Nov 15, 2021 · Fundamentals

Boost Python Speed: 10 Proven Code Optimization Tricks

This article presents practical Python performance tips, covering fundamental optimization principles, avoiding global variables and attribute lookups, reducing unnecessary abstractions, eliminating data copies, leveraging short‑circuit logic, loop improvements, JIT compilation with numba, and choosing efficient built‑in data structures, all illustrated with measurable code examples.

Code Optimizationbest practicesperformance
0 likes · 15 min read
Boost Python Speed: 10 Proven Code Optimization Tricks
Code Ape Tech Column
Code Ape Tech Column
Nov 3, 2021 · Backend Development

Best and Bad Practices for Using Java Optional

This article explains the purpose of Java 8's Optional class, illustrates common misunderstandings, lists several bad usage patterns, and provides a set of recommended best‑practice APIs and tips to help developers handle nullable values safely and elegantly in backend Java code.

Backendbest practicesjava
0 likes · 13 min read
Best and Bad Practices for Using Java Optional
Java Interview Crash Guide
Java Interview Crash Guide
Oct 27, 2021 · Backend Development

Master Java Naming Conventions: From Packages to Enums

This comprehensive guide explains Java naming standards for packages, classes, interfaces, abstract classes, exceptions, methods, variables, constants, enums, generics, and test code, providing clear rules, examples, and best‑practice code snippets to help developers write clean, maintainable code.

backend-developmentbest practicescode style
0 likes · 16 min read
Master Java Naming Conventions: From Packages to Enums
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 25, 2021 · Databases

Common Redis Pitfalls and How to Avoid Them

This article examines frequent Redis pitfalls—including unexpected key expiration, blocking DEL commands, RANDOMKEY performance issues, SETBIT memory spikes, MONITOR OOM risks, persistence challenges, and master‑slave replication quirks—providing detailed explanations and practical mitigation strategies for each scenario.

CachePersistenceReplication
0 likes · 29 min read
Common Redis Pitfalls and How to Avoid Them
Python Programming Learning Circle
Python Programming Learning Circle
Oct 20, 2021 · Fundamentals

Python Coding Style Guidelines (Applicable to Django)

This guide presents comprehensive Python coding conventions—including indentation, line length, quoting, blank lines, encoding, import ordering, spacing, line‑break handling, comment styles, docstring rules, and naming standards—providing clear examples and best‑practice recommendations for clean, maintainable code.

Djangobest practicescoding style
0 likes · 7 min read
Python Coding Style Guidelines (Applicable to Django)
Top Architect
Top Architect
Oct 20, 2021 · Fundamentals

Comprehensive Guide to Git Workflows, Commands, and Best Practices

This article provides an extensive overview of Git workflows, including Git Flow, GitHub Flow, and GitLab Flow, along with practical command references, best practices for commits, branching, rebasing, stash usage, repository cloning, and hook configuration, aimed at improving version control efficiency.

GitVersion Controlbest practices
0 likes · 17 min read
Comprehensive Guide to Git Workflows, Commands, and Best Practices
DevOps
DevOps
Oct 18, 2021 · Product Management

Common Anti‑Patterns in Writing User Stories and Recommended Practices

This article explains three typical anti‑patterns when creating agile user stories—converting requirement documents directly, writing stories only at iteration start, and making stories overly detailed—and presents a recommended backlog‑driven approach with practical steps to improve story quality and prioritization.

Anti‑Patternsbest practicesproduct backlog
0 likes · 6 min read
Common Anti‑Patterns in Writing User Stories and Recommended Practices
Big Data Technology Architecture
Big Data Technology Architecture
Oct 14, 2021 · Backend Development

Effective Code Review and Software Design Principles for Go Backend Development

This article shares practical insights on why engineers and leaders must conduct code reviews, identifies common causes of poor code such as duplication and premature decisions, and presents concrete design principles—including simplicity, composition, transparency, and disciplined logging—illustrated with Go code examples to help teams build maintainable, high‑quality backend systems.

Backend EngineeringCode reviewGolang
0 likes · 39 min read
Effective Code Review and Software Design Principles for Go Backend Development
JavaEdge
JavaEdge
Oct 13, 2021 · Backend Development

Why Inconsistent Naming Breaks Java Projects and How to Refactor It

The article examines how varied naming conventions and outdated coding practices in Java backend projects cause confusion, illustrates the problem with real code examples, and provides concrete refactoring steps—such as adopting Java 8 date‑time APIs and enforcing consistent service naming—to improve maintainability and team cohesion.

Code RefactoringJava 8backend-development
0 likes · 6 min read
Why Inconsistent Naming Breaks Java Projects and How to Refactor It
Programmer DD
Programmer DD
Oct 12, 2021 · Backend Development

31 Proven Java Code Optimizations to Boost Performance

This article presents a comprehensive collection of Java code optimization techniques—from using final modifiers and reusing objects to pre‑sizing collections and avoiding reflection—aimed at reducing code size, improving execution efficiency, and preventing common performance pitfalls in backend development.

Code Optimizationbackend-developmentbest practices
0 likes · 21 min read
31 Proven Java Code Optimizations to Boost Performance
Open Source Linux
Open Source Linux
Oct 11, 2021 · Operations

10 Essential Ops Principles Every Engineer Should Follow

This article shares ten practical operations guidelines—from avoiding duplicated work and embracing mistakes to emphasizing monitoring, backup roles, clear division of labor, and continuous improvement—aimed at boosting reliability, efficiency, and team cohesion for both engineers and managers.

OperationsReliabilitybest practices
0 likes · 10 min read
10 Essential Ops Principles Every Engineer Should Follow
Selected Java Interview Questions
Selected Java Interview Questions
Oct 11, 2021 · Fundamentals

Understanding Java Thread Interruption: Methods, Checks, and Best Practices

This article explains how Java's thread interruption works, covering the interrupt() method, proper ways to check interrupt status, handling InterruptedException in loops, using interrupt‑aware locks, dealing with blocking I/O, and common pitfalls such as swallowing exceptions or attempting to interrupt deadlocked threads.

Interruptible I/OLockThread Interruption
0 likes · 16 min read
Understanding Java Thread Interruption: Methods, Checks, and Best Practices
21CTO
21CTO
Oct 8, 2021 · Backend Development

How to Eliminate Null Checks in Java: Use Null Object Pattern and Best Practices

This article explains why excessive null‑checking clutters Java code, distinguishes valid versus invalid null returns, and shows how to replace them with assert statements, exceptions, empty collections, or the Null Object pattern to write cleaner, more reliable backend code.

AssertNull Object patternbest practices
0 likes · 6 min read
How to Eliminate Null Checks in Java: Use Null Object Pattern and Best Practices
Alibaba Terminal Technology
Alibaba Terminal Technology
Oct 8, 2021 · Backend Development

Which Node.js Core Utilities Should You Upgrade? A Hands‑On Comparison

This article reviews a series of common Node.js utilities—type checking, async sleep, file handling, streams, HTTP requests, assertions, code coverage, debugging, deprecation warnings, source‑maps, child processes, and CLI testing—comparing community packages with built‑in APIs, rating their replaceability, and offering practical migration advice for modern Node.js development.

BackendJavaScriptNode.js
0 likes · 21 min read
Which Node.js Core Utilities Should You Upgrade? A Hands‑On Comparison
Java Captain
Java Captain
Oct 4, 2021 · Backend Development

The Hidden Pitfalls of Using Project Lombok in Java Development

This article reflects on a year of using Project Lombok, showing how its annotations can dramatically shrink Java boilerplate but also introduce version incompatibilities, forced dependencies, reduced readability, tighter coupling, and technical debt that may outweigh its short‑term convenience.

LombokTechnical Debtbest practices
0 likes · 10 min read
The Hidden Pitfalls of Using Project Lombok in Java Development
IT Architects Alliance
IT Architects Alliance
Sep 29, 2021 · Industry Insights

Why Design Patterns Often Fail in Real Projects and How to Make Them Work

The article analyzes common obstacles that prevent effective use of design patterns and code standards in everyday software development—such as performance overhead, class explosion, team skill gaps, project constraints, agile timelines, and staff turnover—and offers practical strategies to balance quality with productivity.

Agile DevelopmentDesign Patternsbest practices
0 likes · 10 min read
Why Design Patterns Often Fail in Real Projects and How to Make Them Work
ELab Team
ELab Team
Sep 29, 2021 · Frontend Development

Mastering Clean CSS: Architecture, Naming Conventions, and Best Practices

This article explores how to write maintainable, readable, and scalable CSS by adopting consistent team guidelines, covering major architectures like OOCSS, BEM, SMACSS, ITCSS, and ACSS, as well as commenting, spacing, and core design principles for high‑quality front‑end code.

BEMCSSPreprocessor
0 likes · 11 min read
Mastering Clean CSS: Architecture, Naming Conventions, and Best Practices
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 27, 2021 · Databases

Redis Usage Best Practices and Guidelines

This article presents comprehensive Redis usage standards—including key naming conventions, avoiding big keys, efficient serialization, safe command usage, data persistence strategies, and operational recommendations—to ensure high performance, memory efficiency, and reliable service under heavy traffic.

Cache ManagementCommand GuidelinesKey Naming
0 likes · 11 min read
Redis Usage Best Practices and Guidelines
Top Architect
Top Architect
Sep 27, 2021 · Backend Development

Java Code Optimization Tips for Better Performance

This article presents a comprehensive collection of Java code optimization techniques—including using final modifiers, reusing objects, preferring local variables, proper resource handling, avoiding unnecessary object creation, and efficient looping—to reduce code size, improve execution speed, and enhance overall application performance.

Code Optimizationbest practicesjava
0 likes · 22 min read
Java Code Optimization Tips for Better Performance
Su San Talks Tech
Su San Talks Tech
Sep 25, 2021 · Backend Development

15 Essential Logging Practices Every Java Developer Should Follow

This article presents fifteen practical guidelines for effective Java logging, covering log levels, parameter tracing, formatting, conditional logging, performance‑friendly APIs, asynchronous output, proper exception handling, and log file organization to help developers quickly locate issues and maintain clean, efficient logs.

best practicesdebuggingjava
0 likes · 10 min read
15 Essential Logging Practices Every Java Developer Should Follow
Python Programming Learning Circle
Python Programming Learning Circle
Sep 24, 2021 · Fundamentals

Four Common Mistakes When Using Python Lambda Functions and How to Avoid Them

This article outlines four typical pitfalls when employing Python's lambda (anonymous) functions—such as returning values, overlooking better alternatives, assigning to variables, and ignoring list comprehensions—and provides practical guidelines and code examples to help developers use lambdas correctly and more readably.

LambdaPythonbest practices
0 likes · 8 min read
Four Common Mistakes When Using Python Lambda Functions and How to Avoid Them
macrozheng
macrozheng
Sep 24, 2021 · Backend Development

15 Essential Logging Practices to Debug Faster and Avoid Blame

This article presents 15 practical logging best‑practice recommendations for Java developers, covering log level selection, formatting, conditional logging, performance‑friendly placeholders, asynchronous output, proper exception handling, and log file organization to improve debugging efficiency and maintainable production systems.

best practicesdebugginglogback
0 likes · 11 min read
15 Essential Logging Practices to Debug Faster and Avoid Blame
IT Architects Alliance
IT Architects Alliance
Sep 19, 2021 · R&D Management

30 Proven Architecture Principles Every Software Engineer Should Follow

This article presents 30 widely‑accepted software architecture principles—grouped into basics, feature selection, server design, distributed systems, user experience, and challenges—to help architects act as gardeners who shape, refine, and sustain robust, maintainable systems.

Distributed SystemsR&D managementSoftware Architecture
0 likes · 12 min read
30 Proven Architecture Principles Every Software Engineer Should Follow
Programmer DD
Programmer DD
Sep 18, 2021 · Backend Development

Boost Java App Performance: 9 Practical Optimization Tips

This article presents nine actionable Java performance‑optimization techniques—from avoiding premature tweaks and profiling bottlenecks to using StringBuilder, primitive types, and caching—complete with code examples and guidance on building a reliable test suite.

Profilingbest practicescaching
0 likes · 11 min read
Boost Java App Performance: 9 Practical Optimization Tips
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 18, 2021 · Fundamentals

How Effective Code Reviews Can Transform Your Team’s Quality

This comprehensive guide explains why code reviews are essential, outlines their benefits and challenges, describes review formats, participants, focus areas, step‑by‑step processes, key operations, principles, and common pitfalls, providing practical advice and examples to help teams improve code quality and collaboration.

Code reviewbest practicescode quality
0 likes · 23 min read
How Effective Code Reviews Can Transform Your Team’s Quality
Python Programming Learning Circle
Python Programming Learning Circle
Sep 14, 2021 · Fundamentals

A–Z of Useful Python Tricks

This article presents a curated A‑Z list of practical Python tricks—including built‑in functions, standard library modules, code snippets, and tips such as using collections, type hints, virtual environments, and command‑line utilities—to help developers write cleaner, more efficient code.

Pythonbest practicescode snippets
0 likes · 15 min read
A–Z of Useful Python Tricks
MaGe Linux Operations
MaGe Linux Operations
Sep 10, 2021 · Backend Development

10 Common Go Mistakes That Kill Performance and How to Fix Them

This article lists ten typical Go programming pitfalls—from undefined enum values and misleading benchmarks to pointer misuse, slice initialization, error handling, context misuse, and goroutine closures—explaining why they hurt performance or correctness and offering concrete, idiomatic solutions.

Error HandlingGobest practices
0 likes · 17 min read
10 Common Go Mistakes That Kill Performance and How to Fix Them
DevOps Cloud Academy
DevOps Cloud Academy
Sep 9, 2021 · Operations

FinOps and DevOps Best Practices for Microsoft ERP Projects

This article explains FinOps as cloud financial operations, outlines how to plan Microsoft ERP projects, and presents eight DevOps best practices—including empowered teams, version control, deployment automation, trunk‑based development, continuous testing, test automation, shift‑left security, and monitoring—while advising on selecting appropriate DevOps tools.

DevOpsFinOpsMicrosoft ERP
0 likes · 10 min read
FinOps and DevOps Best Practices for Microsoft ERP Projects
FunTester
FunTester
Aug 31, 2021 · R&D Management

What Makes an API Document Truly Effective? From Basic to Excellent

The article outlines practical criteria for creating qualified and excellent API documentation, covering project overview, modular organization, request/response details, maintenance practices, and common pitfalls, illustrated with a Jira issue‑creation example, to help testers and developers improve efficiency and communication.

API documentationSoftware qualitybest practices
0 likes · 12 min read
What Makes an API Document Truly Effective? From Basic to Excellent
ELab Team
ELab Team
Aug 20, 2021 · Frontend Development

Why Every Frontend Project Needs a Design Document (And How to Write One)

This article explains why front‑end design documents are essential for reducing risk, improving quality and efficiency, outlines the key elements of a complete document, and provides a practical template and real‑world example to help teams create effective specifications before coding.

best practicesdesign documentationsoftware-engineering
0 likes · 13 min read
Why Every Frontend Project Needs a Design Document (And How to Write One)
WeDoctor Frontend Technology
WeDoctor Frontend Technology
Aug 18, 2021 · Frontend Development

How to Write Clean, Maintainable CSS: Principles and Practical Tips

This article explores why CSS often becomes messy, introduces aesthetic considerations, outlines three core writing principles—less is more, self‑explanatory, reusable—and provides concrete techniques such as naming conventions, formatting, commenting, modularization, and tooling to keep styles clean, readable, and maintainable across teams.

CSSbest practicescode maintainability
0 likes · 17 min read
How to Write Clean, Maintainable CSS: Principles and Practical Tips
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Aug 16, 2021 · Fundamentals

Why Refactoring Matters: Practical Tips and Code Smell Solutions

This article, based on the author’s experience and Martin Fowler’s book, explains what refactoring is, why it’s essential, how to spot code smells, and provides concrete principles and JavaScript examples to improve code design, readability, and maintainability without focusing on performance.

JavaScriptbest practicescode smells
0 likes · 27 min read
Why Refactoring Matters: Practical Tips and Code Smell Solutions
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
Aug 16, 2021 · Fundamentals

Java and Kotlin Exception Handling Best Practices

To improve Java‑Kotlin interoperability, the article recommends treating Kotlin exceptions as unchecked while enforcing Java‑style checked‑exception discipline through lint checks, using specific custom exceptions, avoiding broad catches or throws of Throwable, logging via a Monitor, and never returning from finally blocks to reduce crashes.

Checked ExceptionException HandlingKotlin
0 likes · 9 min read
Java and Kotlin Exception Handling Best Practices
IT Architects Alliance
IT Architects Alliance
Aug 10, 2021 · Fundamentals

Common Pitfalls and Best Practices for Creating Effective Software Architecture Diagrams

This article explains why well‑designed software architecture diagrams are essential, enumerates typical mistakes such as ambiguous symbols, inconsistent legends, and over‑detail, and provides practical guidelines on choosing the right number of diagrams, maintaining consistency, using legends, and keeping diagrams up‑to‑date in modern micro‑service environments.

architecture diagramsbest practicessoftware-engineering
0 likes · 15 min read
Common Pitfalls and Best Practices for Creating Effective Software Architecture Diagrams
Wukong Talks Architecture
Wukong Talks Architecture
Aug 6, 2021 · Databases

Redis Operational Best Practices and Guidelines

This guide presents a comprehensive set of mandatory, reference, and recommended Redis usage standards—including command restrictions, key naming, data sizing, persistence configurations, monitoring, and deployment strategies—to improve performance, reliability, and operational efficiency for production environments.

OperationsPersistencebest practices
0 likes · 9 min read
Redis Operational Best Practices and Guidelines
Code Ape Tech Column
Code Ape Tech Column
Aug 3, 2021 · Backend Development

Why Does Java Leak Memory? Deep Dive into Causes and Prevention

This article explains what memory leaks are in Java, compares them with C++ leaks, describes the garbage collection mechanism, lists common leak sources such as static collections, listeners, and singletons, and provides practical guidelines and tools to detect and prevent them.

Garbage Collectionbest practicesjava
0 likes · 18 min read
Why Does Java Leak Memory? Deep Dive into Causes and Prevention
Programmer DD
Programmer DD
Jul 25, 2021 · Backend Development

Mastering Java Optional: Best Practices and Common Pitfalls

This article explains how Java's Optional can replace null checks, outlines common misuse patterns, and provides practical guidelines and code examples for using Optional safely and effectively in backend development.

Code Examplesbest practicesjava
0 likes · 12 min read
Mastering Java Optional: Best Practices and Common Pitfalls
dbaplus Community
dbaplus Community
Jul 19, 2021 · Cloud Native

Avoid These 10 Common Kubernetes Mistakes to Boost Reliability and Cost Efficiency

This article shares a practical guide to the most frequent Kubernetes pitfalls—from misconfigured resource requests and limits to improper liveness/readiness probes, load‑balancer settings, IAM misuse, pod anti‑affinity, and disruption budgets—offering concrete YAML examples and remediation steps to help operators run more reliable and cost‑effective clusters.

Cloud NativeKubernetesProbes
0 likes · 18 min read
Avoid These 10 Common Kubernetes Mistakes to Boost Reliability and Cost Efficiency
Amap Tech
Amap Tech
Jul 16, 2021 · Fundamentals

Code Refactoring: Concepts, Practices, and Techniques

The article shares practical lessons from refactoring a ride‑hailing order system, explaining Martin Fowler’s definition of refactoring, distinguishing small (renaming, deduplication) and large (architectural redesign) efforts, outlining typical code smells, and detailing a structured pre‑, during‑, and post‑refactoring process to improve maintainability, reduce bugs, and accelerate development.

Code RefactoringSoftware ArchitectureTechnical Debt
0 likes · 19 min read
Code Refactoring: Concepts, Practices, and Techniques
Open Source Linux
Open Source Linux
Jul 11, 2021 · Operations

Mastering Shell Script Best Practices for Reliable Automation

This article outlines practical shell‑script guidelines for automating system and application operations, covering script header conventions, formatting, error handling, safe use of commands, variable handling, file packaging, pipeline restrictions, concurrency locks, logging, and risk‑mitigation strategies to make automation both efficient and secure.

DevOpsLinuxOperations
0 likes · 10 min read
Mastering Shell Script Best Practices for Reliable Automation
IT Architects Alliance
IT Architects Alliance
Jul 11, 2021 · Backend Development

10 Best Practices for Designing a Robust Microservices Architecture

This article explains how adopting ten essential microservice best practices—such as single responsibility, independent data stores, asynchronous communication, circuit breakers, API gateways, backward‑compatible APIs, versioning, dedicated infrastructure, independent release pipelines, and organizational efficiency—helps build a loosely‑coupled, scalable, and maintainable backend system.

BackendDistributed SystemsMicroservices
0 likes · 9 min read
10 Best Practices for Designing a Robust Microservices Architecture
MaGe Linux Operations
MaGe Linux Operations
Jul 8, 2021 · Information Security

How to Secure Every Layer of Your Container Stack: Best Practices

This article outlines comprehensive container security best practices across kernel, container image, runtime, pod, network, node, and cluster components, emphasizing how to harden each layer in Kubernetes environments to protect against attacks and maintain robust, scalable deployments.

Cloud NativeContainer SecurityDevSecOps
0 likes · 9 min read
How to Secure Every Layer of Your Container Stack: Best Practices
ELab Team
ELab Team
Jul 8, 2021 · Frontend Development

How Clean Code Practices Supercharge Your JavaScript Projects

This article explores the importance of clean code in JavaScript, presenting the 3R software design principles, naming conventions, function design, component best practices, and practical refactorings with before‑and‑after code examples to help developers write more readable, reusable, and maintainable frontend code.

best practicesclean coderefactoring
0 likes · 15 min read
How Clean Code Practices Supercharge Your JavaScript Projects
Laravel Tech Community
Laravel Tech Community
Jul 4, 2021 · Fundamentals

Common Enterprise Git Workflows and Best Practices

This article provides a comprehensive guide to common enterprise Git workflows, daily best‑practice tips, essential commands, configuration options, merge vs. rebase decisions, history rewriting techniques, reflog usage, batch history editing, hook scripts, fast cloning of large repositories, and handling work interruptions, all illustrated with clear examples and code snippets.

GitVersion Controlbest practices
0 likes · 18 min read
Common Enterprise Git Workflows and Best Practices
Top Architect
Top Architect
Jul 4, 2021 · Fundamentals

Avoiding Null Checks in Java: Assertions, Exceptions, and the Null Object Pattern

This article explains how to distinguish between valid and invalid null returns in Java, recommends using assertions or exceptions for erroneous nulls, suggests returning empty collections or objects, and demonstrates the Null Object pattern with code examples to eliminate repetitive null‑pointer checks.

Exception HandlingNull Object patternassertions
0 likes · 6 min read
Avoiding Null Checks in Java: Assertions, Exceptions, and the Null Object Pattern
Python Programming Learning Circle
Python Programming Learning Circle
Jul 1, 2021 · Fundamentals

Python Code Optimization Techniques to Accelerate Execution

This article presents a collection of practical Python performance‑enhancing techniques, covering optimization principles, avoidance of global variables and unnecessary abstractions, loop refinements, use of local bindings, short‑circuit logic, JIT compilation with numba, and selecting appropriate data structures to achieve significant speed‑ups.

Code OptimizationProfilingbest practices
0 likes · 14 min read
Python Code Optimization Techniques to Accelerate Execution
ByteDance Terminal Technology
ByteDance Terminal Technology
Jun 30, 2021 · Frontend Development

Why Traditional Frontend Scaffolds Fail and How Cloud‑Based Engineering Solutions Solve It

The article traces the evolution of frontend scaffolding from manual copy‑paste templates to CLI tools, examines maintenance and version‑upgrade challenges, and introduces ByteDance’s cloud‑native “Engineering Scheme” with three initialization methods—template, cloud CLI, and webshell—offering automated, container‑based project creation and a marketplace for best‑practice solutions.

CLICloud Nativebest practices
0 likes · 9 min read
Why Traditional Frontend Scaffolds Fail and How Cloud‑Based Engineering Solutions Solve It
Volcano Engine Developer Services
Volcano Engine Developer Services
Jun 26, 2021 · Operations

How ByteDance Powers Billion‑User Video: RTC & Live Streaming Best Practices

The ByteDance Volcengine meetup showcased four expert talks covering RTC scalability for interactive entertainment, zero‑latency VOD optimization, cutting‑edge H.266 video codec development, and reliable live‑stream event practices, offering deep technical insights into powering billion‑user short‑video services.

ByteDanceVideo Streamingbest practices
0 likes · 4 min read
How ByteDance Powers Billion‑User Video: RTC & Live Streaming Best Practices
Programmer DD
Programmer DD
Jun 24, 2021 · Backend Development

Master Java Exception Handling: 10 Best Practices Every Developer Should Follow

This article presents ten essential Java exception‑handling best practices—including proper resource cleanup, using specific exception types, documenting throws clauses, providing clear messages, catching the most specific exceptions first, avoiding Throwable, logging wisely, and preserving original causes—to improve code readability, reliability, and maintainability.

BackendException Handlingbest practices
0 likes · 10 min read
Master Java Exception Handling: 10 Best Practices Every Developer Should Follow
Java Backend Technology
Java Backend Technology
Jun 20, 2021 · Databases

Avoid These 10 Fatal SQL Mistakes Every Java Developer Makes

Java developers often mishandle SQL, leading to performance, correctness, and maintenance issues; this article outlines ten common pitfalls—from misunderstanding NULL and misusing UNION to neglecting MERGE and batch inserts—and provides practical solutions to write efficient, reliable database queries.

JDBCbest practicesdatabase
0 likes · 11 min read
Avoid These 10 Fatal SQL Mistakes Every Java Developer Makes
Tencent Architect
Tencent Architect
Jun 17, 2021 · Fundamentals

The Importance, Challenges, and Best Practices of Code Review in TDSQL‑C

This article explains why code review is critical, outlines its benefits and common difficulties, describes the TDSQL‑C distributed database architecture, and presents a detailed code‑review workflow, author and reviewer responsibilities, commit conventions, and cultural practices to improve software quality and reliability.

Code reviewTDSQL-Cbest practices
0 likes · 11 min read
The Importance, Challenges, and Best Practices of Code Review in TDSQL‑C
IT Xianyu
IT Xianyu
Jun 11, 2021 · Databases

10 Common Mistakes Java Developers Make When Writing SQL

The article outlines ten frequent errors that Java programmers encounter when writing SQL—ranging from misunderstanding NULL handling to misusing UNION, pagination, and batch inserts—and provides practical solutions to improve correctness, performance, and maintainability of database interactions.

JDBCbest practicesdatabase
0 likes · 9 min read
10 Common Mistakes Java Developers Make When Writing SQL
Code Ape Tech Column
Code Ape Tech Column
Jun 10, 2021 · Fundamentals

Mastering Java Code Style: Key Rules from Google’s Guide

This article presents a comprehensive overview of Google’s Java style guide, covering terminology, file naming and encoding, whitespace rules, import ordering, brace placement, indentation, line length, naming conventions, annotations, Javadoc formatting, and practical coding tips to help developers write clean, readable, and maintainable Java code.

Code FormattingGoogle Style GuideProgramming Conventions
0 likes · 27 min read
Mastering Java Code Style: Key Rules from Google’s Guide
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 9, 2021 · Fundamentals

Why Boilerplate Code Still Matters: Tips for Faster, Cleaner Java Development

This article explores the concept of boilerplate code, its historical analogy to movable‑type printing, the benefits of reusing standard code snippets, practical ways to write, reduce, and optimise boilerplate in Java—including utility classes, enums, model definitions, collection constants, array constants, and complex condition handling.

Boilerplate CodeCode OptimizationDesign Patterns
0 likes · 27 min read
Why Boilerplate Code Still Matters: Tips for Faster, Cleaner Java Development
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 7, 2021 · Fundamentals

How to Master Boilerplate Code in Java for Faster, Cleaner Development

This article explains what boilerplate code is, why it speeds up development, and provides practical Java examples and techniques—including annotations, design patterns, and immutable collections—to write, reuse, and reduce repetitive code while maintaining quality and readability.

Boilerplate CodeCode RefactoringDesign Patterns
0 likes · 23 min read
How to Master Boilerplate Code in Java for Faster, Cleaner Development
KooFE Frontend Team
KooFE Frontend Team
Jun 1, 2021 · Frontend Development

Master Variable Naming: Clean Code Practices for JavaScript

This article explains essential clean‑code techniques for naming variables in JavaScript/TypeScript, covering self‑descriptive, pronounceable identifiers, avoiding type prefixes, using consistent terminology, eliminating unnecessary context, and replacing magic numbers and strings with meaningful constants.

JavaScriptbest practicesclean code
0 likes · 10 min read
Master Variable Naming: Clean Code Practices for JavaScript
DevOps Engineer
DevOps Engineer
May 31, 2021 · Fundamentals

Writing Pythonic Code: Principles, Examples, and the Zen of Python

This article explains the concept of writing Pythonic code—leveraging Python’s language features for clear, concise, and maintainable programs—by contrasting non‑Pythonic examples with idiomatic solutions, illustrating the Zen of Python, and providing practical tips and references for developers.

Pythonbest practicescoding style
0 likes · 7 min read
Writing Pythonic Code: Principles, Examples, and the Zen of Python
DeWu Technology
DeWu Technology
May 28, 2021 · Fundamentals

Static Code Analysis Tools Introduction

Static code analysis tools such as Checkstyle, FindBugs/SpotBugs, PMD, QAPlug, Alibaba Code Guidelines Plugin, SonarLint, and SonarQube help Java developers enforce style, detect bugs, security flaws, and code smells early, reducing costs, improving reliability, and enabling continuous quality monitoring throughout the software development lifecycle.

Tool Reviewbest practicescode quality
0 likes · 13 min read
Static Code Analysis Tools Introduction
Practical DevOps Architecture
Practical DevOps Architecture
May 28, 2021 · Cloud Native

Best Practices for Writing Efficient Dockerfiles

This article explains the advantages of using Dockerfiles for image building, outlines key principles such as single responsibility, commenting, minimalism, proper base image selection, .dockerignore usage, cache optimization, and timezone configuration, and provides a practical example Dockerfile to improve build speed and image size.

Cloud NativeContainerDevOps
0 likes · 7 min read
Best Practices for Writing Efficient Dockerfiles
Intelligent Backend & Architecture
Intelligent Backend & Architecture
May 24, 2021 · Fundamentals

Master Java Best Practices: 75 Essential Tips from Effective Java

This comprehensive guide distills the key lessons from Effective Java, covering static factories, builder patterns, singleton pitfalls, generics, enums, serialization, concurrency, and many other best‑practice recommendations, providing Java developers with actionable advice to write cleaner, safer, and more maintainable code.

Effective JavaGenericsbest practices
0 likes · 83 min read
Master Java Best Practices: 75 Essential Tips from Effective Java
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 19, 2021 · Backend Development

Understanding ThreadLocal in Java: Concepts, Memory‑Leak Risks, Source‑Code Walkthrough, and Best Practices

This article explains what ThreadLocal is, demonstrates how it works with and without it, analyses its source code, discusses potential memory‑leak issues, and provides best‑practice guidelines and a Spring‑Boot example for safe usage in multithreaded Java applications.

Spring BootThreadLocalbest practices
0 likes · 12 min read
Understanding ThreadLocal in Java: Concepts, Memory‑Leak Risks, Source‑Code Walkthrough, and Best Practices
JavaEdge
JavaEdge
May 16, 2021 · Backend Development

Why Your Java ThreadPool May Crash with OOM and How to Prevent It

This article explains the purpose and design of Java thread pools, illustrates common pitfalls such as unbounded queues causing OutOfMemoryError, and provides practical guidelines for configuring bounded queues, naming threads, handling exceptions, choosing rejection policies, and using separate pools for compute‑intensive tasks.

ExecutorOOMThreadPool
0 likes · 12 min read
Why Your Java ThreadPool May Crash with OOM and How to Prevent It
Baidu App Technology
Baidu App Technology
May 14, 2021 · Frontend Development

Deep Dive into Vue 3 Composition API: Design, Analysis, and Practical Implementation

The article thoroughly examines Vue 3’s Composition API, explaining its motivation over the Options API, detailing its function‑based design and TypeScript advantages, addressing concerns about complexity, and offering practical guidance on when and how to adopt it for cleaner, more maintainable component logic.

Component DesignComposition APILogic Reuse
0 likes · 12 min read
Deep Dive into Vue 3 Composition API: Design, Analysis, and Practical Implementation
php Courses
php Courses
May 7, 2021 · Backend Development

Discouraged Laravel Practices and Safer Alternatives

The article examines several Laravel coding patterns that are not recommended—such as using request dynamic properties, model $appends, and ambiguous dynamic attributes—and provides clearer, safer code examples for each case.

Code reviewLaravelbest practices
0 likes · 4 min read
Discouraged Laravel Practices and Safer Alternatives
KooFE Frontend Team
KooFE Frontend Team
May 6, 2021 · Fundamentals

When Are Code Comments Helpful? Best Practices for Clean JavaScript

This article examines the ongoing debate over code comments, explains when comments add value or cause noise, and outlines three practical guidelines—commenting only complex business logic, avoiding log‑type and positional markers—to improve JavaScript code readability.

JavaScriptbest practicesclean code
0 likes · 7 min read
When Are Code Comments Helpful? Best Practices for Clean JavaScript
Top Architect
Top Architect
May 4, 2021 · Backend Development

Best Practices for Exception Handling in Java

This article outlines essential Java exception‑handling best practices, covering resource cleanup with finally or try‑with‑resources, declaring specific exceptions, documenting throws clauses, providing descriptive messages, catching the most specific exceptions first, avoiding catching Throwable, never ignoring or double‑logging exceptions, and correctly wrapping exceptions without losing the original cause.

Exception Handlingbest practicescoding standards
0 likes · 11 min read
Best Practices for Exception Handling in Java
MaGe Linux Operations
MaGe Linux Operations
May 1, 2021 · Backend Development

Avoid Common Django Pitfalls: Performance, Validation, and Save Best Practices

This article walks through typical Django mistakes—inefficient ORM queries without select_related/prefetch_related, misuse of null on CharFields, ordering quirks, forgetting to call clean on save, and improper use of update_fields—offering concrete code examples and fixes to improve performance and data integrity.

best practicesperformancevalidation
0 likes · 11 min read
Avoid Common Django Pitfalls: Performance, Validation, and Save Best Practices
Youzan Coder
Youzan Coder
Apr 30, 2021 · Backend Development

Uncovering Hidden Flaws in a Distributed Lock Implementation: A Structured Code Review

This article examines the business context and collection workflow of a BOS‑integrated service, dissects the distributed lock logic and its execution sequence, and conducts a thorough structured code review that reveals logical, exception, non‑functional, and testability issues while offering concrete improvement recommendations.

BackendCode reviewbest practices
0 likes · 8 min read
Uncovering Hidden Flaws in a Distributed Lock Implementation: A Structured Code Review
Liangxu Linux
Liangxu Linux
Apr 29, 2021 · Fundamentals

10 Proven Debugging Techniques Every Programmer Should Master

Debugging is inevitable for programmers, and this guide presents ten practical strategies—from mindset adjustments and bug reproduction to log analysis, online research, code commenting, breakpoint usage, and even the quirky rubber duck method—to help developers efficiently locate and resolve bugs across any codebase.

best practicesdebuggingprogramming tips
0 likes · 9 min read
10 Proven Debugging Techniques Every Programmer Should Master
KooFE Frontend Team
KooFE Frontend Team
Apr 28, 2021 · Fundamentals

How to Write Clean, Maintainable Functions: Practical Tips & Examples

This article presents essential clean‑code techniques for writing reusable, side‑effect‑free functions—covering default parameters, limiting arguments, avoiding global state and mutable objects, single‑purpose design, abstraction levels, functional over imperative styles, and method chaining—illustrated with clear JavaScript examples.

best practicesclean codefunctional programming
0 likes · 13 min read
How to Write Clean, Maintainable Functions: Practical Tips & Examples
Refining Core Development Skills
Refining Core Development Skills
Apr 28, 2021 · Fundamentals

Seven Tips for Growing from Junior to Senior Engineer

The article outlines seven practical suggestions—strengthening requirement review, proactively improving efficiency, deepening core technical fundamentals, focusing on performance, monitoring production, maintaining a global view, and regularly summarizing work—to help ordinary programmers advance toward senior or expert roles.

Career DevelopmentGrowthbest practices
0 likes · 9 min read
Seven Tips for Growing from Junior to Senior Engineer
MaGe Linux Operations
MaGe Linux Operations
Apr 26, 2021 · Operations

Essential Kubernetes Production Best Practices for Reliable DevOps

This article outlines key Kubernetes best practices for production environments, covering health probes, resource management, RBAC, cluster configuration, networking policies, monitoring, stateless design, autoscaling, runtime resource control, continuous learning, priority handling, zero‑downtime strategies, and failure planning to ensure secure, scalable, and highly available deployments.

Containerbest practices
0 likes · 12 min read
Essential Kubernetes Production Best Practices for Reliable DevOps