This article explains practical code quality evaluation standards—coding conventions, readability, maintainability, duplication, and testability—and introduces the five dimensions used by Iceworks Doctor to score projects, helping teams adopt consistent, high‑quality coding practices.
This article explains how software architects can perform effective software design by modeling domain problems and system architecture, outlines the essential UML diagram types, and shows how to use them across requirement analysis, conceptual design, and detailed design to communicate and control development costs.
This guide outlines the essential knowledge, learning strategies, practical steps, and common pitfalls for aspiring full‑stack engineers, highlighting the advantages of mastering both front‑end and back‑end technologies and how this breadth improves development efficiency and cross‑team collaboration.
The article outlines practical guidelines for naming variables and methods—emphasizing clear intent, avoiding misleading or abbreviated names, leveraging IDE autocomplete, ensuring searchability, and maintaining consistent conventions—to improve code readability, maintainability, and overall software quality.
The article examines why many software engineering interviews rely on poorly designed algorithmic questions, outlines the essential technical and non‑technical competencies interviewers should assess, and proposes concrete criteria for crafting effective, open‑ended interview problems that reveal a candidate’s real engineering abilities.
Becoming a full‑stack engineer requires mastering core web fundamentals, continuously learning diverse languages, frameworks, and infrastructure, practicing rigorous design and code quality, and bridging front‑end, back‑end, and operations knowledge to boost development efficiency, solve problems quickly, and earn peer trust across the tech stack.
This article examines Lombok—a popular Java library that generates boilerplate code—by showing before‑and‑after examples, then detailing five major drawbacks such as JDK incompatibility, forced dependencies, reduced readability, tighter coupling, and overall cost‑benefit imbalance that can turn a seemingly elegant solution into a maintenance liability.
This article explores how software engineers can improve their work by clearly defining roles, applying systematic refactoring strategies, and enforcing quality through team consensus, testing practices, and a strong engineering culture, drawing on over two decades of industry experience.
This guide compiles an extensive collection of online tutorials, video courses, e‑books, official documentation, blog communities, and open‑source platforms covering front‑end, back‑end, mobile, database, cloud, and other fundamental programming topics, helping developers continuously learn and improve their skills.
This comprehensive guide walks you through the fundamentals of system design, covering core concepts, analytical thinking, modeling techniques, architecture classification, design tools, and best‑practice principles to help you build robust, scalable software systems.
In a Cloud+ community salon, three Tencent Cloud senior engineers dissect the three‑stage evolution of software architecture—from monolithic to distributed to AI‑driven—share the iterative design of Tencent Cloud Disk, outline request‑centric high‑availability metrics, advise systematic project takeover, and stress hands‑on learning, proactive incident response, and future‑ready practices while inviting talent to join.
This article explains how software architects can use UML modeling to capture domain problems and system designs, produce clear design documents, and communicate functional, non‑functional, and cost requirements across all stakeholders throughout the development lifecycle.
This article explains how to define appropriate software quality measurement goals, choose quantitative or qualitative methods, apply periodic and lifecycle‑wide metrics, and use visual dashboards to turn measurement data into actionable improvements throughout the development process.
This article explains why quality operation is needed for a transaction platform, describes the origin and problems that motivated the Quality Month, outlines a seven‑element operation plan with goals, strategies, resources, data collection, and evaluation, and shares the results and lessons learned.
This article reports on Tencent’s Gongfeng version‑control system receiving top‑level DevOps standard assessment at the 14th GOPS Global Operations Conference, includes an interview with the system’s director about its design, deployment challenges, future plans, and the broader Chinese DevOps standards initiative.
This article recounts how John Washam, a non‑CS graduate, self‑studied for eight months, created a popular GitHub interview guide with over 130 k stars, and leveraged flashcards, language selection, algorithm fundamentals, and interview tips to secure a six‑figure software engineering position at Amazon.
This article recounts an eight‑year journey from a C++ internship to senior roles at Alibaba and Ant Group, highlighting how mastering Node.js, embracing code review, unit testing, open‑source contribution, and continuous sharing can accelerate a software engineer's career.
In this personal narrative, a former Microsoft engineer shares how embracing versatile learning, solid computer‑science fundamentals, and a professional attitude guided his transition from Mac Office development to front‑end work at Bing Ads and ultimately to leading online document products at Alibaba, offering valuable insights for developers seeking sustainable career growth.
The article explores why peers with similar early abilities diverge over time, shares the author’s own rapid rise after graduation, and outlines five key characteristics—curiosity, optimism, refusing mediocrity, humility, and sound judgment—that consistently distinguish high‑performing young professionals.
From rockets exploding to financial crashes, this article chronicles twenty historic software bugs, detailing their losses, how they unfolded, and the programming mistakes that caused them, illustrating the massive economic and societal impact of faulty code.
The article shares a veteran engineer's reflections on choosing technologies, contrasting trendy versus familiar tools, weighing maintenance costs against productivity gains, and offering a pragmatic decision‑making framework illustrated with real‑world examples from Etsy, Mailchimp, and other projects.
This article offers practical advice for software engineers facing mid‑career challenges, outlining eight actionable principles—from avoiding stagnation and maintaining competitiveness to diversifying income and planning for a transition beyond coding—to help them sustain growth and resilience in a demanding industry.
In this talk, a former Alibaba front‑end leader shares his personal journey from a junior developer working on Taobao’s early YUI projects to leading large, growth‑focused teams, offering practical insights on technical mastery, continuous learning, and effective team management.
This article presents a curated list of twenty essential books for programmers at every stage—from junior to senior, full‑stack, architect, and leader—detailing why each title matters, its key lessons, and how it can guide technical growth, soft‑skill development, and career planning.
Discover a comprehensive overview of common programming positions—from full‑stack software engineers to data scientists, DevOps, and specialized domain experts—highlighting ideal personality traits, responsibilities, and how aligning your interests and strengths with these roles can lead to a fulfilling tech career.
This article outlines 13 practical code‑review standards that help improve software health, ensure quality, foster collaboration, and keep development teams satisfied by focusing on incremental improvements, timely feedback, education, and respectful communication.
At Meituan, leaders stress that mastering technical fundamentals—such as coding conventions, design patterns, and testing—through continuous, high‑standard practice transforms ordinary programmers into efficient, maintainable, and scalable engineers, driving higher quality delivery and long‑term value for the business.
A seemingly simple two‑line code change can stretch into days because of unclear bug reports, unfamiliar features, thorough root‑cause analysis, multiple reproduction paths, impact checks, careful solution design, and comprehensive testing, all of which aim to prevent future regressions.
The article explores why seniority alone doesn’t measure a developer’s ability, explains fixed versus growth mindsets, and offers practical strategies—targeted learning, deliberate practice, embracing business development, and cultivating empathy—to sustain continuous professional growth throughout a software engineering career.
The article explains why large distributed applications quickly become complex, identifies cognitive‑load and collaboration‑cost as the two key dimensions of software complexity, analyses concrete causes such as poor logic, mismatched models, bad API design, naming and testing gaps, and offers practical principles for keeping complexity under control.
The article traces design patterns from Alexander’s 1977 architectural ideas through the GoF’s 1994 catalog, debunks myths that they’re obsolete for simple CRUD, shows their essential role in extensible frameworks and complex SaaS systems, and advises learning them by matching each pattern to the specific problem it solves while grounding them in core OOP concepts and the seven SOLID‑type design principles.
The article argues that code should primarily be written for human readers, emphasizing principles like KISS and DRY, thoughtful commenting, avoiding TODOs, and the necessity of unit tests, while acknowledging trade‑offs and offering practical guidance for producing maintainable, elegant software.
This article surveys the landscape of automatic program synthesis for logic code, covering visual programming, example‑driven generation, code‑completion models, intent inference, NL2SQL, NL2IFTTT, and advanced frameworks like TranX and Debuild, while highlighting current challenges and research directions.
This article introduces the seminal GoF design pattern book, explaining its three main categories—creational, structural, and behavioral patterns—along with examples and links to further readings, aiming to build a comprehensive understanding of software design fundamentals.
This article explores why clean, readable code matters, explains key principles such as KISS and DRY, discusses the role of comments, unit tests, and avoiding TODOs, and offers practical advice for developers to improve code quality and long‑term maintainability.
DiDi’s engineering‑efficiency team progressed from using open‑source tools to building custom solutions and finally platformizing domain‑specific services, creating a three‑layer data platform—data collection, computation, and application—that standardizes metrics, visualizes R&D costs, and enables data‑driven decision‑making across the organization.
The article explains the fundamental role of operating systems in managing hardware resources, scheduling tasks, and isolating applications, then provides a detailed analysis of Huawei's HarmonyOS—including its distributed architecture, microkernel design, deterministic latency engine, high‑performance IPC, unified IDE, and the Ark Compiler—highlighting how these features aim to create a seamless, multi‑device software ecosystem.
The article explains how defensive programming in Java—using guard clauses, validators, and side‑effect‑free assertions—prevents errors, outlines proper exception handling by distinguishing checked from unchecked exceptions, and reinforces the DRY principle, urging developers to abstract repeated logic after three occurrences.
Youzan created an internal A/B testing platform—combining Java/Node SDKs, a real‑time data pipeline, and a metadata‑driven workflow—to enable data‑driven product iteration, granular traffic allocation, automated logging, statistical analysis, and scalable growth insights across its merchant services, while planning further automation and integration.
This article explains how Google, a data‑driven company, improves engineering productivity by combining a dedicated research team, the Goals‑Signals‑Metrics (GSM) framework, and the QUANTS model to create actionable, traceable metrics for code readability and other efficiency goals, while balancing quantitative and qualitative insights.
The author shares a detailed, six‑round Google China engineering interview experience—including personal background, each interview stage from recruiter prescreen to onsite sessions, typical coding and algorithm questions, system‑design challenges, and practical tips for preparation and follow‑up.
This article outlines key professional habits for programmers, from cautiously saying yes and boldly saying no, to building a personal knowledge system, maintaining code standards, conducting code reviews, focusing on one language at a time, and mastering time management and client understanding.
This article examines how DevOps adoption transformed the Agricultural Bank’s enterprise‑level R&D management system, detailing its evolution, the operational and cultural shifts introduced, and practical recommendations for integrating DevOps, agile, and continuous delivery at scale.
This article shares a former Android engineer’s experience moving to Java backend development, comparing the two technology stacks and discussing how dynamic loading, compatibility, memory management, and state handling differ, while offering practical insights for developers considering a similar transition.
This article explores the importance of code review for engineers and leaders, examines common pitfalls such as duplicated code and premature optimization, presents core software design principles like KISS and composition, and offers practical guidelines and Golang examples to improve code quality and maintainability.
The article outlines Meizu's transition from a music‑player company to a mobile and internet service provider, detailing the operational challenges faced across three internet eras, the development of a comprehensive automation and continuous delivery platform, and the role of big‑data‑driven insights in improving quality, efficiency, cost, and security.
This article presents seven hands‑on programming projects—from a Pac‑Man game and a CRUD user‑management system to a weather app, chat socket, CI pipeline, web scraper, and social‑media sentiment analyzer—each with clear learning goals, technology suggestions, and GitHub examples to help developers sharpen their skills.
This article shares practical principles and concrete guidelines for effective code review and backend engineering, covering why reviews are essential, common pitfalls like duplicated code and premature optimization, design philosophies such as composition over inheritance, and actionable rules for maintaining clean, maintainable Go codebases.
The article walks through a candidate’s full Google engineering interview experience—including recruiter screening, phone coding rounds, onsite technical sessions, system‑design challenges, and interview logistics—while offering practical tips and resources to help future applicants prepare effectively.
Defect analysis, when treated as a learning opportunity rather than a cost, can dramatically improve software teams by revealing hidden insights, guiding timely actions, and fostering systematic processes that reduce future bugs and accelerate development efficiency.
Since the early 2000s, embedded software engineers combined hardware expertise with low‑level C and assembly coding, but the shift to complex 32‑bit architectures, IoT demands, and high‑level development tools is eroding the need for deep hardware knowledge, prompting a debate over the future role of traditional embedded developers.
The article details how China Construction Bank's Pacific Credit Card Center adopted the national DevOps standard, achieved a level‑3 continuous delivery maturity, and transformed its internet platform with a micro‑service architecture, automated pipelines, and measurable performance improvements.
The article details Baixin Bank's participation in the GNSEC 2020 summit, its successful DevOps Level 3 assessment across five key projects, the measurable efficiency gains achieved, and expert interview insights on the challenges and future plans for DevOps adoption in the banking sector.
The article details TaiKang Insurance's journey through the GNSEC 2020 DevOps summit, its successful Level‑3 continuous‑delivery assessment, the technical and organizational challenges overcome, measurable gains such as 300% demand parallelism, 50% faster response, and future plans to expand DevOps practices across the enterprise.
Baoxin Software’s Deputy Director of the Industrial Internet Research Institute discusses how their ePlat data collaboration platform passed the national DevOps standard’s Level 3 continuous delivery assessment, revealing the metrics, challenges, and strategic benefits that propelled their software delivery to a leading domestic benchmark.
Anxin Securities’ mobile trading platform recently passed the third‑level DevOps continuous‑delivery assessment, revealing how the firm built an organization‑wide toolchain with open‑source solutions, aligned with CMMI and agile practices, and plans to expand DevOps standards across all its systems.
At the GNSEC 2020 summit, China’s Agricultural Bank showcased how its five diverse projects—ranging from credit middle‑office to personal online banking—successfully achieved Level 3 of the national DevOps continuous‑delivery standard, revealing the challenges, strategies, and future plans behind their rapid, enterprise‑wide transformation.
This article explains the true purpose of code review beyond bug hunting, explores its cultural and quality benefits, and offers seven actionable recommendations—including small batch reviews, frequent cycles, choosing the right reviewers, rapid feedback, modern tools, pair programming, and blending online with offline sessions—to make code reviews more effective.
This reflective essay shares a seasoned NetEase engineer's journey and practical advice on technical mastery, stepping out of comfort zones, overcoming career plateaus, planning long‑term growth, fostering respectful teamwork, embracing open mindsets, and developing business‑focused thinking to thrive in modern software development.
The article explains how adopting a concise, shared checklist for code reviews can reduce subjectivity, improve team trust, and ensure critical quality and documentation standards are met across software projects.
The article explains programming fundamentals by likening code to cooking, defining programming as algorithms plus data structures, illustrating basic concepts such as conditionals, loops, and abstraction through simple code examples, and emphasizing the difference between novice and expert approaches.
The author recounts a massive SAP cloud application that suffered severe slowness due to a forgotten 20‑second wait statement, and shares a comprehensive, ten‑step guide on when and how to safely optimize code, emphasizing analysis, clear goals, and disciplined review.
The KAITIAN framework, built by three Alibaba frontend teams, provides a unified IDE foundation that integrates diverse development scenarios—from Alipay mini‑programs and marketing pages to serverless and IoT—while offering a rich plugin system, performance optimizations, and a seamless UI/UX across front‑ and back‑end workflows.
John Washam, a self‑taught programmer, spent eight months mastering CS fundamentals, building a comprehensive interview roadmap that earned over 100,000 GitHub stars, and ultimately landed a high‑paying AWS role, sharing his language choices, flashcard system, study resources, and interview tips for aspiring engineers.
This article examines why excessive if…else statements harm code readability and maintainability, and presents a range of refactoring approaches—including table‑driven mapping, chain‑of‑responsibility, annotation‑driven, event‑driven, state machines, Optional, Assert, and polymorphism—to replace or simplify them, while also addressing deep nesting and complex conditional expressions.
An ex‑consultant recounts a twelve‑year French government software project that spiraled into a disastrous 600‑plus‑million‑line C++ codebase, plagued by outdated technology, chaotic version control, absurd management practices, and massive inefficiencies, ultimately ending in prison for its leaders.
This article examines the technical evolution of Alibaba's DataWorks platform, detailing the pain points of a monolithic IDE, the transition through componentization, and the adoption of micro‑frontend and plugin architectures to achieve flexible, scalable, and maintainable big‑data development tooling.
This article presents PICC Insurance's digital strategy that leverages a DevOps model to support micro‑service architecture migration, detailing the company's unique DevOps standardization, end‑to‑end processes, quality safeguards, deployment solutions, and efficiency analysis as shared at the GNSEC 2020 summit.
This article explains the six core object‑oriented design principles—Single Responsibility, Open/Closed, Liskov Substitution, Dependency Inversion, Interface Segregation, and Law of Demeter—detailing their definitions, benefits, and Java code examples to illustrate proper application.
The author recounts his personal Google engineering interview journey, detailing each stage—from recruiter prescreen and phone screens to onsite rounds, HR interactions, coding challenges, system design questions, and even lunch—while sharing practical tips, common pitfalls, and resources to help candidates prepare effectively.
In this interview, DevOps veteran Dong Yue shares his journey from a curious Tsinghua student to a leading architect at Alibaba, his influential books on configuration management, the creation of China’s first DevOps maturity model, and practical advice for young engineers seeking purpose and impact.
This article, translated from Google's testing blog, offers practical guidelines on avoiding overly long identifiers, writing clear and precise commit messages, and linking code changes to defect reports to improve code readability and maintainability across software projects.
This interview chronicles Dong Yue’s path from a curious Tsinghua student to a DevOps leader at Alibaba, highlighting his early fascination with software engineering, influential books, the creation of the Aone platform, the national DevOps maturity model, and practical advice for aspiring technologists.
An ex‑army veteran turned self‑taught programmer spent eight months mastering core computer‑science topics, building flashcards and interview projects, and ultimately landed a high‑paying role at Amazon, sharing his detailed study plan, resources, and interview tips via a popular GitHub repository.
This article examines the problems caused by overusing if…else statements in code—such as poor readability, maintainability, and violation of design principles—and presents a collection of refactoring patterns, including table‑driven design, chain of responsibility, annotation‑driven, event‑driven, state machines, Optional, guard clauses, and polymorphism, with concrete Java examples.
In this translated talk, Niclas Hedhman examines why poor code proliferates in the software industry, debunks common myths about development, highlights the hidden challenges programmers face, and proposes practical principles such as the KISS rule to gradually raise code quality and developer satisfaction.
The article argues that, despite the popularity of design patterns, blindly applying the 23 classic patterns rarely improves software quality and often leads to over‑engineered or fragile code, urging developers to critically assess their context, language features, and multi‑paradigm alternatives before using them.
The article explains how junior, mid‑level, and senior developers differ in knowledge, coding practices, problem‑solving approaches, and career progression, emphasizing that experience and mindset—not just years of service—determine a developer’s level and guide the path toward seniority.
The article examines the drawbacks of overusing if...else constructs in software, explains why they harm readability and maintainability, and presents ten practical refactoring methods—including table‑driven, chain‑of‑responsibility, annotation‑driven, event‑driven, state machine, Optional, Assert, guard clauses, and method extraction—to simplify or replace complex conditional logic.
The article outlines Google’s philosophy on code health, emphasizing readable, maintainable, stable, and simple code, and provides practical guidance on writing understandable code, designing robust interfaces, and avoiding primitive obsession to improve developer productivity and software quality.
The article analyses the 2020 Chinese DevOps survey, highlighting the current maturity of agile management, continuous delivery, technical operations, application design, and security, while sharing practical experiences, tool choices, and common challenges faced by enterprises during DevOps transformation.
The article outlines a set of practices for creating a small, self‑managing engineering team that continuously ships code, emphasizing no middle management, outsourcing non‑core work, short weekly tasks, pair accountability, single‑owner projects, and letting underperformers go.
This paper describes Facebook's continuous deployment practice for its Android and iOS mobile apps, outlines the release workflow, presents a seven‑year data set covering commits, crashes, and issue tracking, and analyses how deployment frequency, team size, and release timing affect developer productivity and software quality.
This article presents John Washam's comprehensive, now Chinese‑translated guide covering programming language choices, hardware basics, algorithm and data‑structure fundamentals, flashcard study methods, interview résumé tips, common Google interview questions, and additional efficiency tools, all aimed at helping engineers prepare for Google interviews.
This article explains why overusing if…else harms code readability and maintainability, outlines ten practical methods—including table‑driven, chain of responsibility, annotation‑driven, event‑driven, state machines, Optional, Assert, and polymorphism—to refactor or replace complex conditional logic, and provides Java code examples for each approach.
The article examines why many software projects deteriorate due to poor code quality, outlines four common pitfalls such as oversized components, low cohesion, tangled logic, and rampant if‑else statements, and presents concrete refactoring strategies—including inverted‑pyramid design, lib/framework separation, Template Method pattern, and rich enums—to dramatically improve maintainability and project success.
The article outlines the essential traits of a good programmer, emphasizing solid technical ability, openness to new ideas and continuous learning, habit of summarizing knowledge, strong communication and expression skills, and a realistic view of personal contributions and compensation.
Technical strength is not a fixed metric but a problem‑solving ability that varies by domain, complexity, and depth, and this article outlines a practical methodology—covering hard and soft skills, from points to bodies—to assess engineers during hiring, promotion, and daily work.
This article outlines the typical career progression in software development, describing the duties and expectations of programmers, senior programmers, architects, technical managers, directors, and CTOs, and provides insight into how responsibilities evolve from coding to system design and organizational leadership.
The article recounts a real SAP project where a stray 20‑second wait statement crippled performance, then outlines five actionable principles—including setting clear goals, using profilers, enabling compiler optimizations, targeted code adjustments, and mandatory code reviews—to ensure optimization improves speed without sacrificing quality.
The article examines why a small fraction of developers earn six‑figure salaries while many remain average, outlining seven decisive abilities—raw coding, debugging, simplicity, accurate schedule prediction, low‑level system knowledge, strict key‑design focus, and avoiding perfectionism—that together create a massive performance gap.
This article explains the fundamentals of static code scanning, reviews popular analysis tools such as Checkstyle, FindBugs, PMD and SonarQube, and details a three‑year evolution of a dealer technology department’s CI/CD integration, automation, metrics, and key success factors for effective code quality assurance.
The article explores how disciplined Code Review fosters better software quality, emphasizing that every line of code should have purpose, encouraging concise, well‑named, and well‑documented code, while highlighting common pitfalls such as unnecessary complexity, poor exception handling, and scattered constants.
The article uses the simple task of buying apples to illustrate why programming is challenging, highlighting the need for thorough analysis, exhaustive testing, handling edge cases, and continuously refining processes to avoid bugs and unexpected failures.
Code review, described as a rational dialogue about code, improves team harmony, uncovers hidden bugs, enforces meaningful naming, reduces redundancy, and promotes disciplined practices such as proper spacing, centralized constants, and thoughtful exception handling, ultimately turning every line of code into purposeful, maintainable software.
The article explains how to write clean, expressive code by defining dirty versus clean code, presenting expert guidelines on naming, commenting, function design, and testing, and illustrating each point with concrete good and bad code examples.
This article chronicles John Washam’s journey from a self‑taught web developer to an AWS technical specialist, detailing his comprehensive, now Chinese‑translated, Google interview guide, the learning resources he recommends, and the practical tips and pitfalls he discovered along the way.
This article breaks down the diverse career paths within Linux, detailing the core responsibilities of operations roles—ensuring stable services and data security—and the various development tracks, from application and embedded programming to low‑level kernel and driver engineering.
This tongue‑in‑cheek article enumerates a series of deliberately bad programming practices—from confusing variable names and misleading comments to over‑engineered designs and zero testing—to show how to make code virtually impossible to maintain.
This article explains why a well‑structured resume is crucial for developers, outlines common pitfalls such as overly long skill lists, vague descriptions, and poor formatting, and provides detailed guidance on organizing personal information, crafting concise skill sections, and presenting work and project experience to attract HR attention.
