The article explains why comparing floating‑point numbers with == in Java often yields unexpected results, describes the IEEE‑754 representation of float and double, demonstrates common pitfalls through code examples, and provides step‑by‑step methods for converting decimal fractions to binary.
To tackle mounting complexity in a fast‑growing video streaming platform, the team executed a large‑scale refactor that introduced a vertical‑layered, horizontally modular architecture, enforced coding standards and ArchUnit guards, applied incremental safe refactoring and gray‑release monitoring, ultimately reducing core classes to seven, improving code quality and engineering efficiency.
This article reviews the classic book *Programming Pearls*, summarizing its overview, key problem‑solving case studies such as bitmap sorting and external sorting, practical programming techniques, and personal reflections on how the book cultivates a deeper, more efficient mindset for software development.
The article reflects on the insights from Zhang Xiaolong's WeChat product philosophy, emphasizing that overly complex solutions indicate flawed problems, that engineers should help shape product requirements, that abstraction simplifies systems, and that a strong desire to change the status quo drives innovation and effective technical management.
This article explains how programmers can overcome the hassle of writing documentation by using ChatGPT to automatically generate PlantUML code, covering the basics of PlantUML, prompt engineering, and step‑by‑step examples for class and sequence diagrams.
The author, a decade‑long Git user, explains the pain points of Git, compares it with SVN, Sapling, and Scalar, outlines the features he wishes a version‑control system had, and evaluates whether any existing tool meets those needs.
This article details how Huaisen reshapes the karaoke workflow by introducing innovative features such as clear‑singing pitch‑finding, a comprehensive editing SDK, and intelligent pitch‑correction algorithms, explaining the underlying audio analysis, strategy generation, and system architecture that enhance user experience across recording, editing, and publishing stages.
This article examines technical debt at four time scales—annual, monthly, weekly, and daily—explaining their characteristics, why teams often postpone remediation, and proposes a 25% rule that allocates dedicated time for each type to foster a culture of continuous improvement.
The article explains how AI code reviews suffer from missing context, and improves them by embedding the codebase, using Retrieval‑Augmented Generation to fetch relevant snippets, and adding a function‑calling tool that lets the model autonomously request additional code, resulting in precise, bug‑detecting feedback.
Effective clean‑code practices require precise, unambiguous naming for variables, methods, classes, and packages, because clear identifiers convey purpose, avoid confusion, simplify maintenance, reduce bugs, and support readability, extensibility, and testability, ultimately preventing technical debt and improving team productivity.
This guide explains the value of code comments in embedded development, warns against excessive or insufficient annotation, and provides concrete best‑practice rules, principles, and code examples to help engineers write clear, maintainable documentation within their source files.
This article curates eight essential books and documentaries that explore the rise, decline, and personal narratives of computing—from legendary programmers and the birth of personal computers to the lives of Turing, Jobs, and Tesla—offering insight and inspiration for anyone in tech.
After a year of using Project Lombok, the author reflects on how its annotations dramatically shrink boilerplate but also introduce version incompatibilities, hidden dependencies, reduced readability, tighter coupling, and technical debt, urging developers to weigh its benefits against long‑term maintenance risks.
This article explains how to implement a generic deep‑copy function in Go using reflection, detailing the Interface definition, the Copy and Iface wrappers, the recursive copyRecursive logic, and key techniques such as interface design and recursive traversal to produce fully independent copies of complex data structures.
This article explains why and how to assess R&D productivity by analyzing code quality, complexity, test coverage, commit frequency, and defect density, offering a practical four‑step implementation framework, discussing benefits, challenges, and the risk of metric‑driven development.
This article explains why software engineers should cultivate technical influence, outlines the benefits of building a personal brand, and provides practical steps—including continuous learning, contributing to open‑source projects, writing technical articles, delivering talks, and publishing books—to steadily increase visibility and career growth.
This article explains how Google uses informal design documents to capture high‑level implementation strategies, trade‑offs, and consensus, outlining their structure, lifecycle, and when they add value versus when they become unnecessary overhead for software projects.
AutoDev for VSCode extends the AI-driven coding assistant from IntelliJ IDEA to the VSCode ecosystem, detailing its unified architecture, dependency-inverted plugin system, event-driven UI, core interfaces, test-generation prompts, and the 0.1.0 release features such as custom AI commands, test and comment generation.
Using pinyin in code reduces readability, maintainability, and international collaboration, leading to ambiguity, bugs, and higher maintenance costs, so developers are advised to follow standard naming conventions like meaningful English identifiers, camelCase, and snake_case.
Dave Plummer, a senior Microsoft engineer, explains how a quick‑made formatting dialog created in 1994 as a temporary fix ended up persisting for three decades, shaping Windows UI and even imposing lasting limits on FAT volumes.
A Ukrainian engineer unveils an experimental, nameless programming language built around a single data structure and stack operations, inspired by Forth, APL and PostScript, sparking debate among developers about its practicality, educational value, and the broader challenges of naming in software design.
The article examines Devin, an AI software engineer touted as the world’s first fully autonomous coding assistant, explores its promised capabilities, the skepticism surrounding its performance claims, community reactions, and the broader implications for AI-driven software development.
The article argues that programmers should cultivate product thinking by understanding the background, value, and user impact of features, highlighting how this mindset distinguishes them from pure engineering, improves collaboration with product managers, and helps prioritize genuine user needs over superficial or duplicated functionalities.
This article examines the origins and goals of software development standards, explains why they often break down when enforced through tools, presents concrete examples of such failures, and shares insights from Alibaba's Aone platform that guide the design of a more effective DevOps‑centric R&D workflow.
This article explains how managers can nurture genuine creativity among software engineers by focusing on technical knowledge, collaborative environments, balanced constraints, critical thinking, curiosity, and practical tools, turning creativity into a trainable skill rather than a myth.
This weekly roundup highlights major AI developments such as Google's restructuring of its AI team, Huawei's innovative camera technology, Microsoft's ambitious AI chip accumulation plan, OpenAI's cost‑reduction outlook, Meta's new Llama 3 models, and other notable industry news and expert opinions.
This article presents a thorough guide on modern code review, covering its importance, common obstacles, preparation steps, automation tools, good and bad commit messages, mindset, code quality principles, review workflow, and practical tips for overcoming challenges and improving team engineering culture.
This article shares ten practical Go best‑practice tips—ranging from using a single GOPATH and structuring for‑select loops to defining custom types, adding String methods for enums, and wrapping repetitive logic with context functions—to help developers write flexible, readable, and error‑resistant Go programs.
This article explores how programmers can transform routine tasks into opportunities for deep technical growth by adopting a product‑owner mindset, focusing on quality, continuous improvement, and strategic communication with leadership to secure challenging projects that drive both personal and organizational success.
In 2023, major tech companies like Google, Amazon, and Uber publicly questioned the benefits of microservices, revealing new architectural approaches that promise lower latency, reduced costs, and simpler deployment, while highlighting the challenges and pitfalls that have led many teams to revert to monolithic designs.
This article introduces the open‑source learning_mind_map project, offering 81 curated mind maps that cover topics from C/C++ and Golang to Linux, cloud‑native, databases, DPDK, audio‑video development, and core computer principles, with links to the GitHub repository.
This article examines how large language models (LLMs) are being integrated into DevOps workflows, detailing practical implementations, organizational adoption, efficiency‑boosting techniques, underlying principles, limitations, and future directions for software engineers seeking to leverage AI as a reliable development partner.
This article explains how BizDevOps extends DevOps by integrating business, development, and operations into a unified practice that addresses three efficiency inequalities, defines core capabilities, and provides a comprehensive model and practical framework for digital transformation and sustained high‑quality delivery.
This article adapts the classic "Seven Habits of Highly Effective People" framework to software development teams, explaining each habit—proactivity, beginning with the end in mind, putting first things first, seeking win‑win, understanding others, synergizing, and continuous renewal—and offering concrete behaviors to embed them in daily technical work.
The article surveys modern open‑source AI agent frameworks, defining agents as autonomous perception‑planning‑action systems, outlining core modules (inference, memory, tools, action), comparing single‑agent designs like BabyAGI and AutoGPT with multi‑agent platforms such as MetaGPT and AutoGen, and discussing their benefits, trade‑offs, and future research directions.
This article explores the hidden complexities of dependency management in modern Node.js development, covering the risks of unstable package structures, versioning pitfalls, various dependency types, ghost and circular dependencies, and provides practical strategies and best‑practice recommendations to keep dependency graphs stable, secure, and maintainable.
This article shares a developer's year‑long journey at JD Jinli, covering personal growth, technical innovations such as points‑asset protection, risk mitigation, traffic governance, and communication best practices, while emphasizing how disciplined engineering and collaborative mindset drive business value.
QCon 2024, a premier global software development conference, focuses on AI integration in software development, featuring technical sessions on large language models, AI applications in companies like fast-hand, and practical insights for developers.
AutoDev 1.8 introduces AI‑driven refactoring, commit‑message generation, CLI assistance, and Chinese prompt support, combining software‑development best practices with knowledge‑engineered AI to streamline code changes, improve code quality, and integrate seamlessly into modern DevOps pipelines.
This article presents an in‑depth guide on modern code review, covering its significance, core principles, preparation checklists, automation tools, good and bad commit messages, code quality metrics, naming conventions, security considerations, common pitfalls, conflict resolution, and time‑management strategies for development teams.
This article compiles thirty actionable tips that cover the entire software development lifecycle—from technical selection and tooling to CI/CD, monitoring, and knowledge sharing—helping engineering teams dramatically improve collaboration, productivity, and delivery quality.
The author recounts his early DevOps experiences with continuous integration using TFS, PowerShell, and Azure, reflects on the current undervaluation of DevOps, reviews the “Jenkins 2.x Practical Guide” and highlights sociological insights and practical challenges of adopting CI/CD pipelines.
The Princeton team’s open‑source SWE‑agent equips GPT‑4 with a specialized agent‑computer interface that lets it understand, edit, test, and repair code in real GitHub repositories, achieving state‑of‑the‑art bug‑fixing performance with low latency and cost.
This article outlines ten practical principles for designing applications with large language models, emphasizing a model‑first mindset, precision through interactive disambiguation, clear division of code and model responsibilities, data quality, handling uncertainty, and recognizing the limits of LLMs to build robust, maintainable software.
This article shares actionable advice from a software engineer with eight and a half years of experience, covering habits like keeping work logs, stepping out of comfort zones, staying curious about other teams, joining on‑call rotations, switching teams, blogging, and mindful approaches to introducing new ideas and managing emotions.
LangChain, an open‑source framework that combines large‑language‑model capabilities with code understanding, enables automatic code generation, intelligent code analysis, documentation creation, and interactive programming tutoring, offering software engineers a powerful tool to accelerate development, improve quality, and stay ahead of emerging AI‑driven programming trends.
This article explores the concept of R&D efficiency, outlines its goals, debunks common misconceptions, and presents a practical framework—including practice, platform, and measurement components—supported by visual models to help technology organizations improve delivery speed, quality, reliability, and sustainability.
This article examines why the enterprise mid‑platform once became a popular digital‑transformation strategy, outlines the four main benefits it offered, analyzes the practical problems that led many companies to dismantle it, and provides guidance on when and how organizations should adopt or adapt a mid‑platform approach.
The article explains how interview expectations differ for small, medium, and large companies, and contrasts the priorities of campus recruitment versus social recruitment, offering practical advice on how candidates should tailor their resumes and preparation to match each scenario.
The author reflects on two decades of programming, sharing personal achievements, mistakes, and a comprehensive set of practical recommendations—from choosing the right environment and entrepreneurship to profit models, early‑stage technologies, open‑source contributions, public speaking, and health—aimed at helping early‑career developers fast‑track their growth.
The article examines Jensen Huang’s claim that AI will make programming obsolete, discusses existing AI coding tools, highlights their limitations, and argues that human expertise in design, reasoning, and error‑checking remains essential for software development.
Former LinkedIn senior engineer Chris Krycho reveals how organizational constraints, technical debt, and conflicting migration strategies made modernizing a 2‑million‑line front‑end codebase a multi‑year challenge, offering key insights for large‑scale software refactoring.
The article warns that relying on quick, superficial bug fixes creates hidden technical debt, explains why deep understanding of code changes matters, and offers practical advice to keep code clean, maintainable, and resilient in complex systems.
After fifteen years of software development, the author learns that writing good code demands rapid trial‑and‑error, modular design, SOLID principles, early unit testing, and controlled complexity, while avoiding perfectionism, embracing stakeholder communication, and focusing on high‑ROI learning to create reusable, maintainable tools.
This article explains what a thread pool is—a collection of pre‑instantiated idle threads that execute tasks efficiently—and outlines the essential steps to implement one, including thread creation, container management, and task interface design.
This article presents 18 practical code review guidelines covering comments, logging, naming, parameter validation, exception handling, modularity, concurrency, testing, formatting, compatibility, security, transaction, idempotency, middleware, code smells, and remote calls, offering concrete examples and best‑practice recommendations for Java developers.
This article reviews the 2023 surge of large language models in software engineering, evaluates their current code generation, testing, and knowledge‑query capabilities, highlights persistent challenges in design and maintenance, and proposes concrete recommendations for advancing toward higher‑level intelligent development.
This article explains why C++ template instantiation can cause code bloat and provides concrete, actionable strategies—such as extracting non‑template parts to base classes, using helper abstractions, avoiding unnecessary template parameters, and measuring binary size—to significantly reduce compiled binary size while keeping code maintainable.
In this reflective guide, a CTO shares a year‑long journey from software engineer to technology leader, outlining his career timeline, the evolving definition of the CTO role, a customized framework, and thirteen practical lessons on leadership, delegation, decision‑making, and maintaining technical relevance.
This course introduces the background and features of PHP, explains the role and inner workings of the PHP interpreter—including lexical analysis, parsing, and the virtual machine—and guides students to implement a simple interpreter using C, enhancing their programming and problem‑solving skills.
This article explores the core concepts of software architecture, presenting various definitions from IEEE, Martin Fowler, Ralph Johnson and Neil Ford, and discusses architecture boundaries, the relationship between architecture and detailed design, patterns versus styles, and the knowledge models needed for architects and developers.
The article humorously lists twelve detrimental coding habits—such as over‑splitting microservices, writing excessively long methods, nesting deep conditionals, random variable names, misleading comments, copy‑pasting code, ignoring logs, and reinventing wheels—that reduce code readability and increase maintenance difficulty.
This guide explores practical strategies for programmers to improve communication, handle meetings, manage external dependencies, respond to emergencies, process high‑volume messages, and develop independent, critical, and systematic thinking to become more reliable contributors in software projects.
An experiment conducted on Interviewing.io shows that candidates using ChatGPT can pass 73% of original LeetCode interview questions and 67% of modified ones, while interviewers fail to detect any cheating, highlighting the need for custom interview problems to mitigate AI‑assisted fraud.
The article explains how business and domain modeling—using UML diagrams, RUP‑based workflows, and DDD principles—help engineers bridge the gap between business problems and technical solutions, enabling clearer requirements, stakeholder alignment, and improved system design across complex industries such as finance, logistics, and e‑commerce.
The article examines why every business system accumulates technical debt over time, outlines the stages from initial creation to maintenance decay, analyzes the human and architectural factors that make legacy systems hard to work with, and proposes domain‑modeling and disciplined engineering practices to mitigate and delay that decay.
While AI coding assistants such as GitHub Copilot have accelerated development speed by up to 55% and seen rapid adoption across millions of developers, extensive analysis of 153 million code changes reveals rising churn, copy‑paste, and reduced refactoring that threaten code quality and long‑term maintainability, prompting managers to seek balanced productivity strategies.
This article provides a detailed, step‑by‑step tutorial on enterprise‑grade Git branching models, development processes, common commands, merge strategies, troubleshooting tips, and advanced techniques such as cherry‑pick and rebase, helping newcomers and teams adopt a reliable version‑control workflow.
This article details ICBC Software Development Center's comprehensive approach to performance capacity testing, covering background challenges, a structured quality practice plan, enhanced test scope evaluation, result analysis, tool support, implementation outcomes, and future directions for ensuring system stability and scalability.
A reliable programmer masters timely, clear communication and effective collaboration—replying promptly, managing dependencies, handling emergencies, organizing purposeful meetings, triaging messages, and using concise group‑chat etiquette—while also exercising independent, critical, and systematic thinking to own product decisions, evaluate designs, and break goals into actionable tasks.
Based on DevJobsScanner's analysis of over 10 million global job postings, this report ranks the ten best‑paid programming languages in the United States, detailing average and median salaries, job counts, and industry trends for each language from Java to Solidity.
This article explains the concept, structure, benefits, storage options, workflow integration, common questions, and pitfalls of Architecture Decision Records (ADR), a lightweight documentation practice that helps software teams capture, communicate, and evolve critical architectural decisions effectively.
This article shares practical guidance drawn from over a decade of software engineering experience, illustrating common pitfalls such as false delivery, broken promises, and poor communication, and offering structured advice on setting goals, planning, requirement discussion, coding, code review, and documentation to build a trustworthy professional programmer persona.
The article lists twelve common anti‑patterns—such as splitting microservices per table, writing overly long methods, nesting deep conditionals, random variable names, misleading comments, copy‑pasting code, ignoring logs, and over‑engineering solutions—that dramatically reduce code readability and make maintenance a nightmare.
Recent research and industry observations reveal that developers allocate roughly 58% of their work time to comprehending existing codebases and system architecture, a trend unchanged over four decades, highlighting the critical need for better program‑understanding strategies and collaborative practices.
This article explains the fundamentals of code visualization, why it is needed, presents several real‑world scenarios, and details both static (source‑based and bytecode‑based) and dynamic analysis techniques for generating call graphs, along with their advantages, disadvantages, tools, and case studies.
The guide shows that by consciously designing Go data structures and function interfaces—using pure functions, parameter injection, interface abstractions, struct‑based objects, or function‑variable patterns—and avoiding init(), developers can expose and control all dependencies, making business code inherently testable and achieving high unit‑test coverage.
This guide offers a step‑by‑step 40‑day study plan, exam statistics, recommended resources, weekly tasks, and practical tips to help candidates confidently pass the Senior Software Architecture Designer certification exam.
This article explains typical PHP code smells such as long methods, large classes, duplicate code, excessive comments, complex conditionals, and infinite loops, and provides concrete refactoring examples to improve readability, maintainability, and overall code quality.
The article examines why senior engineers feel anxious when they stop coding, analyzes the trade‑offs between technical depth and managerial responsibilities, compares the roles of technical manager and director, and offers a structured approach for leaders to maintain growth while driving business value.
The article enumerates twenty common bad habits of programmers—from inconsistent terminology and poor documentation to inadequate testing and lack of communication—explaining why they hinder productivity and offering guidance on how to adopt better practices for professional growth.
The 2023 Levels.fyi Global Programmer Salary Report reveals how programmers' compensation varies by city, country, and seniority, highlighting rising median salaries in Beijing, the dominance of AI and blockchain sectors, and the dramatic earnings differences across junior to principal engineering levels.
This article explores how large language models like ChatGPT can be leveraged to transform natural‑language requirements into UML diagrams using PlantUML, demonstrating the workflow, prompt engineering, iterative training, and the resulting efficiency gains for developers.
This guide shares practical methods for creating clear, attractive, and complete diagrams—covering code, architecture, business process, flow, and sequence charts—by applying four design principles, color‑wheel techniques, golden‑ratio composition, and an end‑to‑start mindset to improve developers’ visual communication.
A Chengdu software engineer shares a candid, step‑by‑step recount of his job‑hunting journey, from low‑pay outsourcing traps to tough interview questions on Java, cloud, data structures, and design patterns, culminating in a modest offer and hard‑earned lessons for future candidates.
In this reflective article, a newly appointed CTO shares a year‑long journey from software engineer to technology leader, outlining fourteen practical lessons on leadership, time management, delegation, decision‑making, and the unique challenges of guiding an IT‑service organization.
The 2023 Meituan Technical roundup highlights the ten most‑read articles, ranging from the evolution of its code‑hosting platform and automatic SDK generation to risk‑visualization, trace‑ID recovery, trustworthy A/B testing, KDD research, UI intent detection, MJDK compression gains, large‑scale database high‑availability, and interactive food‑delivery recommendation, each with brief summaries and links.
This article explains the concept, goals, suitable teams, and step‑by‑step process of Mob Code Review (Mob CR), a collaborative code‑review practice that helps teams establish quality standards, educate newcomers, and improve overall code quality through collective inspection and discussion.
This article examines low-code development platforms, outlining their advantages such as reduced cost, lower technical barriers, and faster delivery, while also highlighting drawbacks including limited flexibility, performance and scalability concerns, vendor lock‑in, and challenges with complex projects.
This article revisits defensive programming, explores quirky variable‑naming techniques—including single‑character, Chinese, and multilingual identifiers—and humorously breaks down core OOP concepts while stressing the developer’s irreplaceable role in modern software projects.
The article shares a seasoned backend developer’s reflections on three essential practices—doing, thinking, and talking—highlighting how imitation, continuous questioning, balanced design, collaborative implementation, and effective communication form a lasting framework for personal and professional growth in software engineering.
This article introduces the fundamentals of software modeling and design documentation, explaining how UML diagrams such as class, sequence, component, deployment, use‑case, state and activity charts are used across requirement analysis, conceptual design, and detailed design phases to create clear architectural blueprints.
This article details how Tencent Docs implements a flexible architecture that can switch between monolithic and microservice deployments, describing the motivations, such as framework diversity, configuration conflicts, global variable management, hidden bugs, the custom 'monolith' tool with its configuration format, and the resulting performance and resource savings.
This article explores the essential role of Code Review in improving code quality, fostering knowledge sharing, and enhancing team cohesion, offering practical guidance on what to focus on—from naming conventions and comments to architecture, performance, and security—while also discussing reviewer mindsets and cultural adoption.
This article outlines a systematic approach to mobile architecture design, covering goals, when to create new architectures, requirement analysis, business flow mapping, pattern discovery, layering, modularization, lifecycle interfaces, verification, and evolution, illustrated with a Feed scenario and code examples.
This article explains why clean code matters and provides practical guidelines on naming, class design, function design, and testing—including principles, refactoring examples, and tool recommendations—to help developers write more readable, maintainable, and robust Java code.
The article lists twelve common anti‑patterns—such as over‑splitting microservices, writing excessively long methods, random naming, misleading comments, and avoiding logging—that dramatically reduce code readability and increase maintenance difficulty, illustrating each with a fictional developer’s missteps.
This article presents a comprehensive collection of R&D efficiency metrics and their calculation formulas, covering code integration, quality, productivity, reliability, maintainability, and deployment aspects, to help teams evaluate and improve development performance and operational effectiveness.
Analyzing over 10 million global developer job postings (focused on the United States) from November 2022 to November 2023, DevJobsScanner identified the top ten highest‑paying programming languages, detailing average salaries, median wages, and the number of paid positions for each language.
This article introduces ten useful Python decorator patterns—such as timing, logging, authentication, caching, input validation, retry, permission checks, type checking, singleton, and call counting—explaining their purpose, providing clear code examples, and showing how to apply them to enhance functions and classes.
