This article outlines eight practical, actionable guidelines—ranging from acknowledging what you don’t know to collaborating one‑on‑one with peers—that can dramatically boost your programming skills and help you become a more effective, self‑driven developer.
This article outlines Baidu's continuous integration methodology, detailing how test coverage types, build system reuse and pipeline design, and team habits are coordinated to achieve efficient, stable, and product‑line‑aligned software delivery.
The article explains how programmers need long, uninterrupted periods of deep work (the "quiet" mode) to solve complex problems, while managers thrive in a meeting‑driven "worldly" mode, and argues that balancing these two states and protecting developers from mid‑day interruptions can dramatically improve productivity.
The article examines the shortcomings of visual programming tools for data scientists, highlighting issues such as poor version control, limited IDE flexibility, lack of open‑source integration, and reduced modularity, and argues that code‑first approaches remain more effective in enterprise environments.
The article applies Freud's conscious‑unconscious model to programming, describing four (and a possible fifth) stages of competence illustrated with real‑world examples, and argues that this psychological framework effectively explains skill development for developers.
This article examines the two main types of poor developers—‘cowboy’ programmers who rush code without maintainability and mediocre coders lacking competence—explores their harmful habits such as spaghetti code, endless bugs, and arrogance, and outlines how good developers differ through humility, responsibility, and continuous learning.
This article explores the DRY principle in software development, explains why many open‑source projects violate it, and provides practical guidance on selecting, using, and customizing open‑source solutions through real‑world case studies, focusing on business fit, maturity, operational capability, and safe integration.
This article shares eleven practical rules for software developers, ranging from treating technology as a tool rather than a solution, writing clear code, avoiding unnecessary code, limiting comments, planning before coding, testing thoroughly, continuous learning, enjoying coding, acknowledging unknowns, adapting best practices, and striving for simplicity.
The article explains why developers need to understand operations—covering resource usage, fault handling, platform basics, and essential ops tools—so they can write maintainable code, avoid common pitfalls, and collaborate effectively with ops teams for reliable, high‑performance services.
The article examines why developers often produce low‑quality, hard‑to‑maintain code, outlines common bad‑code patterns, discusses the limited benefits and high costs of refactoring, and offers practical advice for writing better, more maintainable software.
The article provides comprehensive guidelines for writing high‑quality functions, covering naming conventions, parameter design, and body implementation techniques such as reducing nesting, avoiding mutable inputs, and using clear verbs to improve readability, maintainability, and testability across programming languages.
Margaret Hamilton, the pioneering software engineer behind the Apollo Guidance Computer, overcame gender bias, invented key software engineering practices, and laid the groundwork for modern computing, illustrating how early system programming turned a daring space mission into a historic triumph.
The article argues that while writing code is essential, the true goal of developers is to minimize code through thoughtful design, using tools that reduce errors, and continuously refactoring to keep code clear, maintainable, and a harmless by‑product of solving problems.
This article shares a 14‑year journey of building and evolving website architectures, from a simple personal homepage to billion‑page platforms, highlighting essential accumulation, knowledge structuring, design principles, infrastructure, software engineering practices, and the nuanced differences across business systems.
The article outlines five practical steps—adopting a proactive mindset, shifting from passive to active learning, understanding the purpose of the technology, hands‑on experimentation with official quick‑start guides, deep‑dive reading, teaching, and community involvement—to help engineers rapidly master new IT tools and frameworks.
This article explores a new platform capability model that integrates business support, development support, and operational control, arguing that a platform should be treated like a product with clear responsibilities, measurable outcomes, and a closed‑loop approach to sustain long‑term value.
The author recounts how strict coding standards at Google transformed his view, showing that uniform indentation, naming, and comment styles dramatically improve code readability, speed up understanding across teams, and outweigh common objections about creativity, flexibility, or perceived waste of time.
This article explains how to objectively assess code quality by defining good code, discussing readability, documentation, exception handling, concurrency, performance, logging, maintainability, modularization and providing recommended reading, helping developers and reviewers establish consistent evaluation standards.
The article explains Alibaba's continuous delivery theory, tools, and best‑practice pipeline—including integration, testing, deployment, and release—illustrated with diagrams and a detailed description of how the platform improves software quality, collaboration, and operational resilience in large‑scale cloud environments.
The article compiles insights from developers on Quora about the attitudes and habits—such as lack of patience, poor use of Google, 9‑to‑5 mindset, weak memory, giving up early on errors, focusing only on output, and missing enjoyment—that signal someone may struggle to succeed as a programmer.
In this interview, senior technology specialist Yu shares practical strategies for creating effective learning plans, becoming an expert through deliberate practice, balancing full‑stack skills, choosing sustainable technologies, and overcoming growth plateaus in a fast‑changing software industry.
The article recounts the author's seven‑year path learning data structures and algorithms, from neglect in college to self‑study, book recommendations, internships at Microsoft and Baidu, projects such as a T‑SQL parser and a pinyin index, and reflections on the importance of algorithms.
The article examines how Google maintains high code quality through rigorous code reviews, strict style guides, active code‑health initiatives, fix‑it events, and a strong testing culture, while also discussing the perception that older code inevitably degrades.
The author reflects on a programmer's focus on web, distributed systems, and data processing, arguing that deep, continuous investment in fundamentals—such as algorithms, networking, and OS concepts—drives lasting skill growth, better project outcomes, and a healthier professional mindset.
This article recounts a career experiment where a senior software engineer named Bill reshaped his résumé to emphasize managerial experience, navigated two contrasting interview processes, and analyzes how social status and perceived leadership affect hiring outcomes in the tech industry.
This article explores the essential concerns of iOS client‑app architecture—including network API handling, page presentation, local persistence, and dynamic deployment—while offering a step‑by‑step methodology, insights on layer design, and a critical look at the drawbacks of using a generic Common folder.
This article examines why developers produce low‑quality, hard‑to‑maintain code, describing common anti‑patterns such as unclear intent, unreadable logic, poor organization, and missing abstractions, and discusses the difficulties of refactoring such code, while offering insights into recognizing and improving code quality.
The paper examines how machine‑learning systems inherit unique forms of technical debt—such as boundary erosion, entanglement, hidden feedback loops, and data‑dependency issues—and discusses mitigation strategies, measurement techniques, and cultural changes needed to maintain sustainable, reliable ML deployments.
The author, a programmer with 32 years of experience, argues that continuous self‑education and staying abreast of emerging technologies are personal responsibilities, not the employer’s, illustrating this through a series of career anecdotes spanning from early microcomputers to modern mobile and web development.
A developer survey of 4,500 programmers reveals that naming variables, classes, and functions is perceived as the biggest programming challenge, highlighting its impact on code readability, design quality, and maintenance, and underscoring the art and difficulty of choosing concise, meaningful identifiers.
The article explains how to write robust, error‑free code by always using two‑branch if statements, handling return values and exceptions correctly, avoiding null‑pointer pitfalls, and steering clear of over‑engineering through practical examples and clear best‑practice guidelines.
The article presents a comprehensive philosophy on software development, emphasizing the importance of repeatedly refining code, structuring it elegantly, modularizing with clear functions, avoiding unnecessary comments, and adopting simple, intuitive practices to improve readability and maintainability across any programming language.
This article uses historical and everyday analogies—from Levi Strauss’s gold‑rush jeans to a simple power‑plant demonstration—to explain the core nature of software development, why traditional factory‑style management fails, and how agile practices, continuous integration, and quality standards drive modern software engineering.
This article summarizes the core concepts of "The Geek and the Team", highlighting humility, respect, and trust as pillars for effective software team collaboration, and provides practical guidance on culture, leadership, handling disruptive members, organizational influence, and user relationships.
This article uses historical and everyday analogies—such as Levi’s jeans and car factories—to explain the core principles of software development, emphasizing continuous design, iterative production, quality, efficiency, and the need for agile engineering practices.
This article shares practical programming philosophy and concrete techniques—such as iterative code refinement, modular design, readable naming, avoiding unnecessary language features, and clear control flow—to help developers consistently produce elegant, maintainable, and bug‑free code.
The article reflects on a veteran programmer’s 32‑year journey, emphasizing that staying current through self‑driven education, exploring new languages and technologies, and not relying on employers for training is essential for long‑term success in the ever‑evolving software industry.
This article explores practical programming philosophies for writing robust, maintainable code by using exhaustive two‑branch if statements, proper error handling, disciplined null‑pointer management, and avoiding over‑engineering, offering concrete examples and guidelines for Java and other languages.
While many developers know they should avoid certain coding shortcuts, this article reveals nine surprisingly common bad programming habits—like using goto, skipping documentation, over‑compressing code, and redefining operators—that programmers often cling to, explaining their origins, risks, and occasional hidden benefits.
The article argues that visible over‑time and frantic activity often mask poor software design, while quieter teams that focus on solid architecture, SOLID principles, and unit testing deliver higher quality code, challenging traditional notions of effort in tech management.
In this interview, Xiaomi R&D architect Ouyang Chen shares the design philosophy, evolution stages, core modules, pitfalls, and future challenges of the Xiaomi advertising platform, offering practical insights for building scalable backend systems.
This article outlines the common pitfalls programmers face on the path to web architecture, emphasizes mastering object‑oriented fundamentals, design patterns, and refactoring, and provides a detailed roadmap of the technical, operational, and managerial knowledge required to become a competent web architect.
A seasoned programmer in his late fifties shares five practical pieces of advice—ranging from staying true to your roots and embracing chaos to pruning code, leveraging experience, and prioritizing health—to help aging developers remain productive and fulfilled in the fast‑moving software industry.
This article explains why clear, self‑describing naming and adherence to coding conventions are essential for readable, maintainable software, illustrating common pitfalls with bad examples and showing improved alternatives that convey intent without relying on comments.
This article explains why clear, self‑describing naming is essential for professional programmers, illustrates common pitfalls with bad examples, and provides concrete guidelines on intent‑revealing, unambiguous, appropriately‑sized, convention‑compliant, domain‑aware names to improve code readability and collaboration.
This tongue‑in‑cheek chronicle traces the evolution of programming languages—from the 1801 Jacquard loom’s punched‑card instructions and Ada Lovelace’s theoretical algorithm, through Turing’s universal machine, the birth of FORTRAN, Lisp, COBOL, C, Java, and up to modern JavaScript—mixing factual milestones with satirical commentary.
This article outlines eight distinct programmer career levels—from the "Immortal Programmer" to the "Terrible Programmer"—explaining their characteristics, typical roles, and examples, while highlighting cultural differences in career expectations between China and abroad.
The article explores the definition of a programmer, outlines essential skills and daily responsibilities, discusses common career pitfalls, and provides practical advice on personal branding and professional growth for software developers.
Matt Welsh, a former Harvard CS professor now at Google, details his typical workday at both institutions, highlighting the stark contrast in coding time, meetings, and personal routines, offering insight into modern software engineering and academic life.
A graduate student recounts the shocking code quality issues he found in his team's data‑mining project, highlighting bad naming, massive classes, duplicated logic, overuse of singletons, excessive comments, and other anti‑patterns that jeopardize maintainability and graduation.
This article explores why technical experts often lack management experience, outlines the typical career stages of a developer, and provides practical guidance on shifting mindset, setting team goals, allocating resources, improving communication, and fostering empowerment to become successful technical managers.
The author compares Chinese and US software engineers, highlighting stark differences in communication style, problem‑solving ability, technical depth, passion for coding, and broader expectations such as leadership and vision, while noting that only a small elite in each country truly excel.
This guide explains why good naming is essential for maintainable C++ code, presents eight concrete principles—such as being true to the name, avoiding misleading terms, using searchable identifiers, and leveraging meaningful context—and shows bad versus good examples for variables, functions, classes, and constants.
This article presents eighteen core programming principles—from DRY and KISS to the Open/Closed and Law of Demeter—that help developers write cleaner, more maintainable code, reduce bugs, and adapt to change effectively.
The article reflects on Dennis Ritchie's legacy, describing how his work on UNIX and the C language emerged from curiosity, stepping out of comfort zones, innovative thinking, and a philosophy of sharing that still influences modern software development and open‑source culture.
The article critically examines how the DevOps and full‑stack trends, driven by startup culture, force developers to juggle multiple roles, leading to overwork, reduced focus, and higher costs, while also highlighting nine companies that successfully practice DevOps.
Programmers can strengthen their personal brand by showcasing products, leveraging company and team reputation, contributing to open‑source, maintaining technical blogs, publishing books, obtaining patents and certificates, and cultivating a solid reputation, all of which enhance visibility and career opportunities.
The article emphasizes that programmers achieve the software engineering iron triangle of cost, speed, and correctness by thoroughly understanding problems, crafting clear designs, listing test conditions, considering impacts on other components, and anticipating future issues, urging a slower, long‑term perspective before diving into code.
The article examines Google’s massive 2 billion‑line code repository, compares its size to Windows, explains how the single‑repo approach and the Piper version‑control system enable thousands of engineers to collaborate across data centers, and discusses the broader impact on software engineering practices.
The article argues that strict coding standards often hinder creativity and teamwork, explaining why the author abandoned them in favor of trusting developers' judgment and focusing on results rather than imposed rules.
A former Alibaba insider recounts how the enigmatic engineer known as ‘Duo Long’—a non‑technical graduate turned P11 senior leader—single‑handedly designed and maintained critical systems like TFS, Tair, cache, and search, embodying relentless focus, self‑learning, and a true craftsman spirit.
The article argues that without clear evaluation standards, software architecture should be judged by how well it achieves the architect's design goals, emphasizing maintainability as the key criterion to balance performance, security, scalability, cost, and long‑term evolution.
The article argues that while performance is important, maintainability is more critical for sustainable software development, illustrating this with anecdotes, common misconceptions about optimization, and practical advice on balancing code readability, caching, and hardware considerations.
The author chronicles a seven‑year evolution from a clueless undergraduate to a seasoned programmer, detailing the books, courses, internships, and personal projects that shaped his understanding of data structures and algorithms, while debating the practical value of algorithmic knowledge in software development.
To accelerate your career as a newly minted software engineer, adopt the four critical habits of the top 1%: investing in learning and tooling, taking decisive action, acting immediately, and maintaining full‑stack understanding, which together enable rapid, high‑impact contributions.
Drawing parallels between Three Kingdoms figures and web framework components, the article explains how each module—from the entry point to data and cache layers—functions, offering practical insights into designing clear, maintainable, and high‑performance backend architectures for modern web applications.
The article argues that the full‑stack developer role is largely a myth, explaining employers' unrealistic expectations, the ever‑growing skill stack, and why the term often masks a desire for "amazing people" rather than a clearly defined technical profile.
The article explains that a programming language serves as a system to encode, name, and organize algorithms, discusses the misuse of the term “algorithm,” illustrates classic algorithms like Dijkstra’s and Euclid’s with code examples in Forth, PostScript, and Python, and emphasizes the DRY principle and efficiency concerns in software development.
The article outlines seven common counterproductive habits—lack of passion, avoiding testing, ignoring usability, saying "no" too quickly, resisting learning, poor teamwork, and neglecting security—that hinder software engineers' productivity and offers expert insights on how to overcome them.
This guide outlines a comprehensive learning strategy for new programmers, covering what to study, effective study methods, specialization, practical coding practice, sharing knowledge, and staying updated with industry trends to accelerate career growth.
The article outlines practical habits—using Google for research, setting SMART goals, managing code on GitHub, logging learning, reading regularly, and mastering shortcuts—to help programmers break through the advanced‑beginner plateau and accelerate toward senior expertise.
The article examines why software engineers are often seen as hard to communicate with, shares Nicholas C. Zakas' experiences and analogies, and offers practical advice such as involving engineers early, minimizing interruptions, granting creative space, and providing timely appreciation to foster better collaboration.
The article argues that while programmers obsess over performance gains, maintainability is often more critical, illustrating this with C# LINQ vs Single/First debates, database design pitfalls, and the hidden costs of premature optimization, ultimately urging developers to prioritize readable, maintainable code and measure performance before refactoring.
The article argues that rewriting already‑deployed code rarely adds real product value, incurs high costs and risks, and should only be considered when the existing system is so outdated that a fresh start is the only viable solution.
This guide walks software engineers through six career phases—from college student to tech director—offering practical advice on goal setting, choosing employers, early‑career pitfalls, management fears, and how to keep growing while avoiding common regrets.
The article argues that deep mastery of programming fundamentals, guided by classic textbooks and a focused career path, is essential for long‑term success, and it explains how personal branding, positioning, and promotion amplify a developer's professional impact.
The article reflects on an engineer's experience updating a signature system, highlighting the pitfalls of quick patches, the importance of requirement analysis, resource testing, realistic time estimation, and proactive communication, and advocates for a refactor to improve maintainability and role perception.
The article outlines a step‑by‑step approach for engineers to quickly learn new IT technologies—emphasizing proactive mindset, active learning, leveraging official documentation, hands‑on practice, and sharing knowledge to achieve mastery and stay competitive in a rapidly evolving industry.
This article explores the stages of programming expertise, defines what makes an expert in software engineering, and offers practical daily habits and mindset shifts that can help developers transform from competent coders into truly great professionals.
The article offers practical advice for programmers to improve their professional growth by carefully evaluating tasks before saying yes, learning to say no when necessary, building a personal knowledge system, maintaining a big‑picture view, adhering to coding standards, conducting code reviews, and continuously learning business knowledge.
This article lists and explains the nine most frustrating tasks programmers encounter—from designing solutions and writing tests to naming variables—highlighting each task's difficulties and featuring candid comments from developers about their daily struggles.
The article argues that humility, honest self‑assessment, and the willingness to admit ignorance are essential personal traits for programmers, enabling them to manage mental fatigue, reduce errors, and continuously improve beyond their current abilities.
A humorous story about a graduate student’s unreadable code illustrates why naming is the toughest programming challenge, and the article then outlines six clear principles—avoiding metaphors, keeping names short, shortening expressions, using active voice, steering clear of jargon, and breaking rules when necessary—to improve code readability and maintainability.
This article examines the common obstacles that prevent teams from adopting pair programming, outlines the substantial benefits such as higher code quality and team cohesion, and provides practical strategies and step‑by‑step methods for introducing pair programming in both co‑located and distributed software development teams.
This article recounts how Tencent’s advertising team introduced and scaled a rigorous code review process—starting with the Rietveld system, adopting Google C++ coding style, and establishing metrics and ownership—to improve code quality, knowledge sharing, and engineering efficiency across multiple departments.
The article outlines a two‑dimensional model of programmer development, describing progressive stages of coding skill—from non‑programmer to language expert—and parallel levels of domain knowledge, while discussing paradigms, design patterns, architecture, and practical advice for advancing in software engineering.
Software architecture is described as a set of critical decisions about system organization, including the selection of components, their interfaces, and collaborative behavior, and as a compositional style that progressively assembles these elements into larger subsystems, a definition comprehensively presented by Booch, Rumbaugh, and Jacobson in the UML User Guide.
The article argues that striving for flawless code is futile because most software constantly evolves, and it advocates focusing on correctness, readability, and pragmatic refactoring rather than chasing unattainable perfection.
While elegant, well‑crafted code can be admired, the article argues that treating software as art often distracts from practicality, emphasizing that true programming excellence is measured by efficiency, reliability, and rapid problem‑solving rather than aesthetic bragging.
The article distills 17 career‑tested principles for developers, urging them to prototype for real customer needs, treat security as inevitable and strategic, prioritize simple, well‑logged code, continuously learn, adapt to change, evaluate context‑specific solutions, deliver results that satisfy clients, and choose projects wisely.
The Joel Test offers a fast, 12‑question checklist that lets you gauge a software team’s practices—from source control and build automation to testing and quiet workspaces—helping you spot critical weaknesses and improve overall productivity in just minutes.
The article explains the Norris constant—initially 1,500 lines, later 2,000 and 20,000—as a practical bottleneck where novice programmers’ code becomes unmanageable, arguing that disciplined design, simplicity, and strategic “no” decisions are essential to break these limits and sustain large‑scale software.
The article compares the low entry thresholds and favorable work environments for programmers in the United States with the stricter conditions in China, analyzes why many self‑proclaimed experts lack deep knowledge, and offers practical advice for individuals and companies to thrive in today’s software industry.
The article shares a founder’s hard‑earned lessons on preventing code‑base entropy, hiring the right first engineer, and gradually improving code quality so that a growing startup can transition from a solo coder to a well‑structured engineering team.
When inheriting tangled legacy code, first decide if you’re responsible and willing to invest, then establish comprehensive tests, use version control, make incremental changes, separate cleaning from bug fixing, remove dead code and comments, avoid mutable shared state, and eliminate unnecessary complexity to improve maintainability.
This article profiles fourteen of the most influential programmers, detailing their key contributions, awards, and the high praise they receive from peers, offering a concise overview of the individuals who have driven major advances in software, algorithms, and open‑source technology.
After years of using Ruby, I discovered that Clojure’s carefully designed, concise, and functional nature not only makes prototyping feel natural but also provides instant feedback and encourages thoughtful refactoring, turning development into a smooth, enjoyable flow that has quickly become my favorite language.
The article compares programmers to doctors, arguing that both solve problems with rational methods, and outlines three core principles—dedication before enjoyment, rigorous attitude, and a willingness to share—to help developers elevate their professionalism and deepen their problem‑solving capabilities.
