This article surveys hacker culture, tracing its roots from 1950s MIT clubs to modern tech giants like Facebook, outlines core hacker values, shares insights from seminal works such as 'The Cathedral and the Bazaar,' and offers practical advice for cultivating a hacker mindset in today’s DevOps era.
A technical director recounts a month‑long, troubled e‑commerce project—detailing its background, the cascade of quality and management mistakes, the intensive code‑review rescue, and the hard‑earned lessons on design, delegation, and balancing speed with quality.
In this interview, former Facebook Tech Lead Ge Jun shares how rapid yet sustainable development, trust‑based culture, and practical DevOps practices boost R&D efficiency, offering concrete process, engineering, personal, and management strategies along with measurable metrics for tech teams.
This article explores six practical ways to accelerate Java development—from hand‑writing and copy‑pasting to Excel formulas, code‑generation tools, and custom generators—detailing their workflows, sample code, advantages, drawbacks, and how to choose the right method for any project.
Interviews with 14 IT experts reveal that slow adoption, skill shortages, costly manual processes, and insufficient organizational support hinder automated testing, while opportunities exist through better tooling, containerization, and focused training to improve ROI and software quality.
An overview comparing Python and PHP highlights Python’s readability, rapid development, and broad applicability versus PHP’s server‑side strengths, detailing each language’s limitations, advantages, typical use cases, and why developers increasingly favor Python for diverse projects.
This article explains why clean code matters—reducing reading time, easing project continuation, speeding up new‑developer onboarding, and supporting consistent coding patterns—and provides six practical tips, from readable formatting to regular code reviews, to help developers produce cleaner, more maintainable software.
This article details JD.com’s agile transformation of its Shopping App, describing the challenges faced, the comprehensive agile maturity diagnosis model, measurement methods, improvement planning, and practical success tips for scaling agile across large, distributed development teams.
This article explains a comprehensive Git branching strategy for large projects, detailing the roles and workflows of master, develop, hotfix, and release branches, and how they support product development, testing, and release management.
Engineer.ai, an Indian AI startup that touted AI‑assisted app development and raised millions in funding, is now sued for allegedly exaggerating its AI capabilities, with evidence that human engineers performed the work, highlighting a broader issue of deceptive AI companies.
The article reflects on the challenges of shaping a sustainable team culture, shares personal experiences of transitioning from a traditional telecom background to mobile product development, and proposes concrete habits and a "product engineer" mindset to align engineering with product and data‑driven decision making.
The Ctrip Technology Salon held on August 3 in Shanghai gathered agile experts from Qunar, Vipshop, Hellobike, China UnionPay, Xinben Agile, and the Electronic Industry Press to share measurement systems, full‑process agile project management, agile‑driven publishing, rapid startup practices, business agility, and product innovation driven by community needs.
This article provides an overview of Python, covering its origin, historical releases, key features, major application domains such as web development, AI and data analysis, various interpreters, and development guidelines like PEP 8.
The article argues that Scrum falls short of true agility, critiques its rigid framework, labels it as fragile when mis‑implemented, and shares personal insights on why simple priority queues often outperform Scrum in software development.
This guide outlines how engineers can succeed as technical project managers by setting clear goals, aligning people and processes, and mastering each phase of the project lifecycle—from initiation and requirement review to scheduling, design, testing, release, and retrospective analysis—while mitigating common risks.
The article shares practical strategies for programmers to boost efficiency, emphasizing solid fundamentals, thorough documentation reading, thoughtful planning with sketches, disciplined task lists, regular reflection, focused work sessions, healthy sleep and exercise, and dedicated learning time to overcome common productivity anxieties.
The article describes Tubi's three‑month experiment to replace traditional waterfall and rigid sprint models with a flexible Release Train system, outlining the motivations, principles, team roles, tooling choices, successes, and areas needing improvement for a fast‑growing startup.
The article explains how company software projects differ from school practice projects in terms of pre‑built scaffolding, version‑control collaboration, multiple deployment environments, remote debugging, structured logging, and the need for permission approvals, offering practical guidance for newcomers to professional development.
This article adapts William J. Donovan’s sabotage manual to reveal how easy it is to undermine an agile team’s efficiency and how practical tactics—like over‑reliance on supervisors, ignoring feedback, and over‑building features—can silently destroy true agility.
This article provides a detailed overview of Git as a distributed version control system, covering installation on Windows, global user configuration, core concepts such as working directory, repository, staging area and HEAD, typical branching workflows, remote repository setup, and a collection of frequently used Git commands.
TIOBE's June ranking shows Python soaring to a record 8.53% share, surpassing C++, and predicts that if this growth continues, Python could replace Java and C within a few years to become the most popular programming language.
In this interview, Microsoft Asia Research chief Zou Xin shares his extensive software engineering experience, discusses the evolution of software development, offers practical advice on learning AI, and reflects on his books and upcoming GIAC conference activities, providing valuable insights for engineers and students alike.
This article traces GitHub’s evolution from a weekend project in 2008 to a $75 billion Microsoft acquisition, examining its innovative free‑plus‑paid model, community‑driven growth, strategic product decisions, and the lessons it offers for product and R&D management.
This case study details how a user product center team applied the APD agile methodology and stream development practices—such as visual value streams, explicit process rules, WIP limits, bug‑board visualization, workflow management, and an evolved TDD approach—to double throughput, cut delivery cycles by 60%, and reduce monthly bugs from 50 to 2, demonstrating measurable R&D efficiency gains.
Linus Torvalds, the creator of Linux, began programming at age 11, built the OS inspired by Minix and Unix, leveraged community support, and exemplifies traits such as intense focus, modesty, and dedication, offering valuable lessons for developers and highlighting the historical evolution of open‑source operating systems.
This article reviews the top ten programming languages, explains why learning multiple languages matters, and offers practical advice on choosing the most beneficial language for your career, covering Java, JavaScript, Python, Kotlin, Go, C#, Swift, Rust, PHP, and C/C++.
This article examines the debate over writing documentation in agile projects, explains how to create effective agile documentation using user stories, compares it with traditional project documentation, and offers concrete guidance and examples to help teams adopt a more efficient, value‑driven documentation approach.
This article explains why agile projects treat documentation differently from traditional projects, outlines the logical and structural differences, shows how to write user stories that pair Why and What, and provides practical guidance for creating concise, value‑driven agile documentation.
The article explores what a bug really is, why bugs inevitably appear in software development, and offers practical strategies—such as effective logging, leveraging debugging tools, and keeping iteration sizes small—to locate and resolve bugs more quickly.
The article examines why many consider Java outdated and inflexible, discusses its ecosystem, JVM strengths, comparisons with newer languages, and ultimately argues that despite its age Java remains a viable backbone for large‑scale software development.
This article explores the most famous software development laws—from Murphy's Law to Moore's Law—explaining their meanings, origins, and practical implications for coding, project management, and system design.
The article examines why seemingly outdated technologies such as SQL remain valuable, critiques the overhyped promises of TypeScript and Docker, and urges developers to balance new trends with proven fundamentals for sustainable software engineering.
This article chronicles a Chinese computer science graduate’s step‑by‑step evolution from learning basic C and Java in university to building campus apps, winning software contests, mastering Spring, Hadoop, Elasticsearch, and Neo4j, and ultimately landing offers from top tech firms, illustrating the challenges and perseverance required for a successful software engineering career.
The article argues that programmers should devote the majority of their limited time to mastering transferable fundamentals and design principles rather than constantly chasing the latest frameworks, using the Lindy effect and personal experience to illustrate this sustainable learning strategy.
The article analyzes the difficulties of quantifying software R&D efficiency, critiques common measurement methods, proposes two guiding principles—global over local metrics and result over output—and presents a comprehensive set of delivery efficiency, quality, and capability indicators with calculation logic.
To keep product development sustainable, prioritize user‑reported bugs first, then self‑discovered bugs, followed by user‑requested features and finally internal ideas, using continuous ranking based on impact, difficulty, and supporter count while actively listening to users and fixing problems before adding new functionality.
This article recounts how an agile coach helped Alibaba Health's B2B development team overcome chronic release failures, burnout, and low productivity by establishing stable feature teams, aligning goals, tightening quality gates, clarifying requirements, visualizing flow with Kanban, implementing continuous integration, and driving continuous improvement through clear metrics.
This article introduces Joel Spolsky's six pivotal recommendations for aspiring programmers, covering the importance of writing skills, mastering C, studying micro‑economics, seeking hands‑on coding courses, overcoming outsourcing fears, and securing relevant internships to boost career impact.
Explore the 25 most essential computer science interview questions, covering core concepts from hardware and operating systems to networking, software development, AI, and security, with concise answers designed to help aspiring developers and IT professionals ace technical interviews.
This article argues that proactive planning is more constructive than passive year‑end summaries, explains how setting clear goals, breaking them into tasks, estimating time, and using simple tools like spreadsheets and Gantt charts can improve personal and professional productivity, even amid rapid change.
This article explores how understanding human nature and sharpening cognition can dramatically improve developers' technical abilities, offering practical examples ranging from technology selection and debugging to interviews, code reuse, and open‑source strategy.
This article explains the differences between git reset and git revert, shows how each command moves the HEAD pointer, demonstrates step‑by‑step examples for undoing erroneous commits, and advises when to prefer revert to preserve history and avoid forced pushes.
The article clarifies common misconceptions about waterfall and agile, explaining that both approaches require thoughtful planning, adaptability, and value‑driven delivery rather than merely executing a fixed plan or abandoning planning altogether.
This guide outlines the ten core competencies—from data structures and version control to IDEs, databases, Unix, Excel, programming languages, networking, and scripting—that every new or aspiring software developer should master to build a successful career.
This article presents a collection of practical Pythonic techniques—including variable swapping, efficient looping, string concatenation, proper file handling, list manipulation, destructuring assignment, and dictionary iteration—to help developers write cleaner, more memory‑efficient, and more readable Python code.
This article explains the Agile Fluency Model, describing its four progressive layers—Focusing, Delivering, Optimizing, and Strengthening—detailing the benefits, required investments, typical timeframes, and practical guidance for organizations to assess, improve, and sustain agile team performance.
The article shares practical methods for reducing bugs throughout the software development lifecycle, emphasizing early communication with product managers and testers, thorough design and code reviews, mandatory unit testing, continuous integration, and proactive log monitoring to ensure smooth testing and delivery.
This article presents seven practical techniques—including using IntelliJ IDEA, upgrading to JDK 8+, adopting Maven/Gradle, leveraging Lombok, writing unit tests, refactoring incrementally, and gathering regular customer feedback—to help developers produce shorter, clearer, and more maintainable Java code.
In this reflective essay, Dan Abramov lists numerous programming topics—from Unix commands and low‑level languages to containers, serverless, microservices, and functional concepts—that he admits to not fully mastering, highlighting the inevitable knowledge gaps even experienced engineers face.
The article argues that developers should devote the majority of their learning time to timeless fundamentals—design patterns, clean code, and architecture—rather than constantly chasing the latest frameworks and tools, using personal anecdotes and a mentor dialogue to illustrate the point.
The article explains three software release models—Project Release, Release Train, and Intercity Express—detailing their constraints, benefits, drawbacks, and how they relate to branch strategies and delivery frequency in continuous delivery practices.
The article explains how fast iteration, thorough business domain modeling, layered module design, minimal‑responsibility interfaces, and automated exception feedback can together boost backend development productivity and reduce maintenance costs in modern software projects.
This article provides a comprehensive overview of essential Git commands, covering repository initialization, staging, committing, branching, merging, remote synchronization, tag management, and configuration, enabling readers to effectively manage version control workflows in software projects.
The article explores why programmers must continuously adapt to fast‑changing internet technologies, offers practical viewpoints on tracking disruptive trends, deepening fundamentals, and evaluating code quality, and provides guidance on choosing and learning the most valuable skills today.
This essay explores the history and inevitability of software bugs—from Grace Hopper’s famous moth to today’s massive codebases—examining developer attitudes, debugging practices, and why writing less code may be the only realistic way to reduce bugs.
The article reviews the October 2018 TIOBE programming language rankings, highlighting shifts such as Go moving into the top ten, SQL’s re‑entry, Rust’s slight decline, and provides a historical top‑10 trend chart while explaining the index’s methodology and its relevance for developers.
This article analyzes the advantages of Gerrit’s pre‑commit CHANGE workflow and GitLab’s Merge Request, proposes a hybrid code‑review service that integrates both approaches, and outlines the scenarios where each method or their combination best fits development teams seeking higher code quality and efficient integration.
Learn essential yet less‑frequent Git commands—including how to amend commits, combine multiple commits, swiftly resolve merge conflicts using ‘theirs’ or ‘ours’, and batch‑delete tags—complete with practical examples to streamline version control for projects of any size.
This article explains agile development’s core business goals of faster value delivery and effective learning, defines agile as early value delivery and adaptive response, and presents a comprehensive five‑group metric system—including release capability, demand response cycle, throughput, built‑in quality, and external delivery quality—to assess and improve continuous delivery performance.
This article explains how agile development aims to accelerate value delivery and improve learning by contrasting waterfall’s batch approach with iterative delivery, introducing the anti‑Moore law, defining agile’s core objectives, and presenting a five‑group metric system to measure continuous delivery capability.
This essay explores how differing philosophies between closed‑source and open‑source software drive distinct business models, legal risks, and innovation pathways, highlighting open source's growing influence across AI, blockchain, DevOps, licensing, and cloud computing.
This article presents a curated collection of Alibaba Group’s open‑source projects, spanning frontend design systems, Java libraries, database engines, distributed file and messaging systems, as well as tutorials, highlighting each project's purpose, key features, and GitHub repository links for developers seeking robust, production‑grade solutions.
Improving code quality requires adopting Clean Code principles—clear naming, purposeful comments, consistent formatting, robust error handling, small single‑responsibility classes, shared conventions, and a disciplined workflow that integrates pre‑commit checks, automated static analysis, code reviews, and continuous metric monitoring to ensure each change is cleaner than the last.
A Chinese R&D team struggling with long cycles, manual releases, and low quality applied four iterative agile improvements—visual work boards, refined requirement splitting, stable test environments, and automated pipelines—resulting in a 75% reduction in development time, higher test automation, and reliable daytime releases.
A project manager reflects on a four‑month development effort that collapsed after launch, analyzing mistakes in quality control, trust, ownership, requirement handling, and code review, and shares concrete steps taken to fix the issues and key lessons learned for future projects.
This article explains how development teams can use a single‑release Git workflow—creating release branches from master, managing feature branches, merging or rebasing, tagging, pull‑requests, and cleaning up branches—to streamline development and deployment.
The article lists 36 common bad habits that hinder programmers' productivity, grouping them into code organization, team work, coding practices, and testing/maintenance, and explains why each habit reduces efficiency and how to overcome them.
This article presents a detailed skill‑tree and practical learning roadmap for software engineers, covering computer fundamentals, data structures, Java core concepts, multithreading, JVM internals, databases, distributed systems, personal branding, and effective study methods such as videos, books, and paid resources.
This guide explains why reading framework source code is essential for developers, outlines step‑by‑step methods such as researching online, scanning packages, locating entry points, systematic reading, organizing insights, and applying critical thinking to deepen understanding and improve coding practice.
The project report details how the Virtual General Service Voucher Center Phase II was delivered using agile methods, achieving higher delivery speed, improved quality, and greater business satisfaction through iterative planning, visual kanban boards, daily stand‑ups, self‑organizing teams, engineering best practices, continuous improvement, and active stakeholder involvement.
The article explains how lacking a real‑time functional requirements design document leads to high communication costs, misaligned expectations, costly rework, and testing nightmares, and it offers practical guidance on where to store, what to include, and how to maintain document quality for successful software development.
Learn how to use Git's cherry-pick command to selectively copy individual or ranges of commits from one branch to another, with step‑by‑step examples, command syntax, and tips for handling multiple commits and postponing automatic commits.
The article examines why many large, well‑known tech companies suffer from messy code, chaotic development processes, and reliance on outdated technologies, exploring the underlying personnel dynamics, reconstruction costs, and the tension between business and technical value.
This article explains the importance of version control systems for collaborative software development, outlines the differences between distributed and centralized VCS, offers best‑practice guidelines, and compares popular open‑source tools like Git, Mercurial, and SVN.
This article shares practical, experience‑based advice on introducing agile methods in software projects, emphasizing tailoring practices to specific contexts, problem‑driven adoption, and essential rules such as physical Kanban boards, daily stand‑ups, and clear Scrum roles, illustrated with multiple real‑world case studies.
This article explains the concept and advantages of continuous integration, outlines a typical CI workflow including submission, testing, building, deployment and rollback, discusses challenges in test case management, reviews popular CI tools such as Jenkins and Qone, and details code‑coverage measurement using Jacoco with Maven configuration.
The article recounts how a monolithic 66,000‑line home‑page system with high latency and tangled logic was re‑engineered through clear direction, module‑based design, and incremental changes, resulting in dramatically faster feature rollout, lower learning cost, and improved performance metrics.
Through a series of candid developer anecdotes—ranging from accidental production database truncations and hidden mistakes to the dangers of coding while exhausted and the importance of version control—this article highlights practical lessons for safer coding practices, rigorous reviews, and disciplined operational procedures.
This article explains Git’s four areas (working, staging, local repository, remote repository) and five file states (origin, modified/untracked, staged, committed, pushed), detailing step‑by‑step commands such as git add, commit, push, and how to revert changes using git reset, checkout, and clean.
The author recounts how discovering Agile and Extreme Programming in 2008 transformed his software development mindset, improved project delivery, and reshaped organizational and product design practices, illustrating both the benefits and challenges of adopting Agile in a traditionally waterfall‑focused environment.
The Elasticsearch Team Development Constitution outlines a comprehensive set of principles and guidelines—covering design philosophy, code quality, interaction etiquette, and organizational responsibilities—to help the rapidly growing project evolve into a reliable, secure, scalable, and user‑friendly distributed search engine.
Understanding and applying solid methodologies—such as design patterns, coding standards, and domain‑driven design—constitutes the core of software development best practices, helping programmers evolve from “wild” coders to professionals who write clean, maintainable code and continuously improve through disciplined practice.
This article compiles a series of Chinese-language resources on user story mapping, explaining how the technique helps agile teams create clearer backlog, prioritize features, and plan releases, offering both theoretical background and practical steps for effective implementation.
The article argues that, in most cases, developers who work on Linux gain skills faster than those who stay on Windows because of richer open‑source resources, fewer APIs to master, and easier access to high‑quality reference implementations.
This article recounts how a small, multi‑disciplinary channel development team applied a customized Kanban‑based agile process to overcome tight schedules, heavy workloads, and a critical three‑day emergency feature request, demonstrating both the strengths and limits of agile in fast‑changing environments.
LightMerge, Ctrip’s integration accelerator, addresses the challenges of merging multiple feature branches by automatically detecting conflicts, merging selected branches, and integrating with CI pipelines, thereby streamlining the multi‑feature branch release process and improving development efficiency and code quality.
This article describes how the Agricultural Bank's software development center introduced daily builds, automated testing, Kanban boards, and Scrum stand‑ups across three phases to boost development efficiency, product quality, and team collaboration, sharing lessons learned and outcomes from the pilot projects.
This article explains why open‑source software is vital, defines what open source means, and provides a detailed, illustrated workflow—from forking a repository on GitHub to creating pull requests and merging code—so developers can start contributing effectively.
This article presents typical developer‑product manager interactions, highlights common wrong replies, and provides concise, professional answers that improve collaboration, reduce friction, and keep projects on track.
This article outlines nine recurring problems—from mismatched teams and unrealistic requirements to relentless overtime and ignored personal lives—that drain developers' energy and sabotage software projects, offering insight into how these issues arise and why they persist.
The 2018 Stack Overflow Developer Survey, with over 100,000 respondents, reveals that most developers are relatively new, many lack formal CS degrees, enjoy high job security, favor JavaScript and SQL tools, and display distinct demographic and ethical trends across the global software industry.
The article explains how DevOps combines culture, practices, and tooling to enable organizations to deliver applications and services more rapidly by breaking down silos between development and operations, fostering cross‑functional collaboration, automation, and continuous improvement throughout the software lifecycle.
This article explains why agile development is needed, outlines its advantages over traditional waterfall methods, defines agile and scrum, and provides practical guidance on preparing teams, tools, and processes before launching an agile project.
This article shares ten practical pieces of advice for programmers—from thinking before coding and communicating clearly with product managers, to writing documentation and comments, handling changing requirements, prioritizing business value, testing thoroughly, solving problems independently, and using new technologies wisely.
The article explains that there is no universal silver‑bullet methodology for software projects; instead, teams must analyze each project's unique variables, blend existing frameworks, and continuously refine a simple, tailored process to achieve effective results.
This article explains why developers should incorporate diagramming into their workflow, outlines three key uses—understanding problems, facilitating team communication, and merging ideas—reviews various media from pen‑and‑paper to code‑generated charts, and offers practical tips for creating clear, effective diagrams.
The article outlines a three‑stage learning path for Python—from mastering basic syntax and common libraries, through intermediate mastery of domain‑specific tools and Pythonic coding practices, to advanced project‑level considerations like documentation, distribution, and performance optimization—while recommending key books for each stage.
Creating an internal developer community fosters open feedback, trust, and collaboration, enabling managers to gather valuable insights, improve documentation and tooling, and ultimately deliver products that meet user expectations and drive higher retention across emerging fields like IoT.
This reflective essay examines how agile development, flat management, and engineering culture intersect, contrasting traditional control‑heavy standards like ISO9000 and CMM with the open, collaborative approaches exemplified by Linux, Scrum, and modern tech giants, and explores how organizations can nurture both rigor and innovation.
This article provides a comprehensive guide to software project management, covering risk assessment, cost budgeting, client communication, requirement analysis, development planning, quality assurance, and product delivery to help teams deliver successful software solutions.
