This guide explains how to ensure Git is installed, create annotated tags, commit changes, push tags to a remote repository, list and switch to existing tags, and delete both local and remote tags using command‑line Git commands.
This guide outlines why Git and GitHub are essential for modern development, when to start learning them, and provides a structured four‑stage roadmap—from basic concepts and commands to advanced workflows and GitHub features—plus practical resources and interview tips.
This article details how the used‑car technology team at Autohome optimized R&D efficiency through standardized workflows, task decomposition, unified time‑based measurement, rigorous demand review, flexible branching, CI/CD pipelines, and data‑driven metrics, resulting in higher throughput and reduced bug rates.
This article clarifies the distinct roles of Quality Assurance (QA) and software testing, explaining their definitions, objectives, methods, and how they complement each other within the software development lifecycle to ensure product quality.
From the early days of COBOL and Fortran to modern languages like TypeScript, Rust, and Go, this essay reviews the evolution of programming languages, discusses criteria for selecting a language, and recommends the most versatile and powerful options for developers in 2022.
The article explains how shift‑left testing, rooted in the waterfall model, moves testing activities earlier in the software development lifecycle to reduce defect‑fix costs, improve quality, and make developers the primary owners of product quality.
The article outlines ten common errors that organizations commit while attempting to adopt Agile, explaining why each mistake hampers true agility and offering guidance on how to involve teams, focus on value, and foster a collaborative culture for successful Agile transformation.
This article explains why version control systems like Git need well‑defined branching strategies, outlines the goals of such strategies, compares popular models—including GitFlow, GitHub Flow, GitLab Flow, Trunk‑Based Development, Scaled TDD, and Release Flow—and offers guidance on selecting the most suitable approach for a development team.
This article compares the traditional Waterfall development model with the Agile Scrum approach, outlining each method's strengths and weaknesses, describing Scrum roles and workflow, and offering practical insights on when and how to apply either model in software projects.
This article examines whether Linux can meet the daily development and office needs of programmers, comparing its graphical interface, development tools, communication apps, Android support, and overall advantages such as efficiency, freedom, and lower resource consumption against Windows.
The article argues that programming seems hard because traditional education fails to build a positive interest loop, neglects problem‑solving training, and does not teach students how to create, suggesting that fostering curiosity, practical projects, and an experimental mindset can make learning to code much more approachable.
This article compares the traditional Waterfall model with Agile and Scrum practices, outlining each approach's strengths, weaknesses, roles, and workflow steps, and offers practical guidance on when to apply one method over the other in software projects.
This article compares the traditional Waterfall development model with Agile methodologies, outlines Scrum roles and workflow, highlights each approach's strengths and weaknesses, and emphasizes the importance of team consensus for effective software project management.
This article presents a concise collection of essential programming principles—including KISS, DRY, YAGNI, writing code for maintainers, lazy development, and testing discipline—explaining their origins, practical applications, and how they help developers produce simpler, more maintainable, and higher‑quality software.
The TVP low‑code technology sharing event featured a heated debate on whether low‑code will dominate mainstream development over the next decade, complemented by a round‑table discussion on its applications, open‑source collaboration, and impact on developers and enterprises.
This article explores the cultural, historical, and practical reasons behind developers' quirky code comments, presents amusing examples from various languages, shares statistics on comment density, and reflects on how these annotations affect teamwork, code readability, and developer morale.
The article examines why programmers frequently copy and paste code, argues that responsible reuse of open‑source snippets can boost productivity while respecting intellectual property, and emphasizes that the key is understanding what to copy, how to integrate it, and ensuring it solves real project problems.
In this firsthand account, a technical leader describes how adopting the Apifox API testing and mock tool transformed their small company's development workflow, cutting interface testing, integration, and client support times dramatically while improving code quality and overall team efficiency.
The article examines how modern development teams often overlook critical aspects of the Agile manifesto—particularly code quality and system flexibility—by reviewing the evolution from waterfall to Agile, highlighting common pitfalls, and suggesting practices such as CI/CD, DevOps, and modular design to sustain rapid, reliable delivery.
The article argues that writing code should be a by‑product of thoughtful problem solving, urging developers to reduce unnecessary code, improve code clarity, and spend more time designing and reviewing solutions to boost productivity and maintainability.
This article outlines seven common bad habits—such as duplicate code, stubborn personal styles, neglecting code‑style fixes, poor optimization knowledge, refusing help, ignoring health, and giving up too quickly—that can harm developers' productivity and project quality, and explains how to avoid them.
This article explains the concept of configuration, enumerates various configuration sources such as hard‑coded values, project files, file‑system files, network‑based stores, JVM startup parameters and OS settings, and discusses their advantages, disadvantages, and suitable usage scenarios for developers.
According to the latest August TIOBE ranking, Python's market share rose to a record 15.42%, while other languages such as PHP, Go, Ruby, Rust, and Kotlin experienced notable position changes, reflecting shifting popularity trends across the programming ecosystem.
This article explains the differences between remote and distributed software teams, outlines the advantages of a distributed model, and provides practical strategies, tools, and communication techniques for effectively coordinating and leading large, multi‑location development projects.
Functional programming, once a niche paradigm, is rapidly entering mainstream software development as teams adopt pure functions, immutability, and higher‑order functions to reduce bugs, improve modularity, and manage the growing complexity of large codebases across many languages and frameworks.
Software Development Life Cycle (SDLC) outlines the structured phases—from idea and requirement analysis through design, implementation, testing, deployment, and maintenance—guiding teams to build, manage, and evolve software efficiently, ensuring project timelines, budgets, and quality meet stakeholder expectations.
This article compiles sixteen practical coding habits—from self‑testing changes and validating method parameters to handling concurrency, resource cleanup, and cache consistency—providing concrete examples, code snippets, and clear guidelines that help developers avoid common bugs and improve overall software quality.
This article explains how to improve overall delivery efficiency by systematically breaking down testing tasks, setting realistic schedules based on clear goals, preparation steps, granular time estimates, dependency considerations, and post‑execution reviews, while emphasizing a target testing effort not exceeding half of development time.
This article traces the evolution of software development practices from the linear Waterfall model through Agile iterations to the integrated DevOps culture, highlighting each approach's principles, advantages, and key differences for modern engineering teams.
This article explains why proper logging is essential for software maintenance, outlines the purposes of logs, describes the requirements for readable, performant, and space‑efficient log output, and details Log4j components, log‑level hierarchy, and concrete code examples for TRACE, INFO, DEBUG, WARN, and ERROR logging.
This article explains the three common Git pull‑request merge strategies—Merge, Rebase, and Squash—detailing their advantages, disadvantages, and suitable scenarios, and provides practical recommendations for developers to choose the appropriate method when integrating code changes.
In the digital age, software development itself must be digitized, using the Flow Framework's five flow metrics to gain end‑to‑end visibility, identify bottlenecks, and continuously improve delivery efficiency across value streams.
This article explains the importance of proper logging in software, outlines common logging requirements such as readability, performance, disk usage, and timeliness, and details Log4j components, log level definitions, hierarchy, recommended usage, and provides concrete macro and log‑statement examples.
This article explains what software development tools are, outlines six essential criteria for selecting the right tool for a project, and reviews popular options such as GitHub, Chrome DevTools, Atom, Cloud9, UltraEdit, Slack, Buddy, HTML5 Builder, NetBeans, Stack Overflow, IntelliJ IDEA, and Visual Studio Code.
An API is a single function that lets one program use another’s features, while an SDK is a comprehensive toolkit containing that API and additional resources; this article uses everyday analogies and real-world examples to clarify their relationship and practical usage in software development.
This guide explains the concept of Continuous Integration, its benefits for early error detection and quality improvement, outlines core principles, detailed workflow standards, recommended practices, daily development steps, and key metrics to monitor CI effectiveness.
This article explains the differences between remote and distributed teams, outlines the benefits of a distributed model, and provides practical tips, communication strategies, meeting structures, video documentation methods, and team‑management practices for successfully running a distributed software development project.
This article offers practical guidance for aspiring self‑taught software developers, covering why software matters, essential foundations, language choices, core tools like CI/CD and DevOps, and strategies for steadily building knowledge and craftsmanship.
This article provides a comprehensive overview of agile development and Scrum, explaining core concepts, roles, artifacts, workflow stages, and practical implementation tips through a real-world case study, while also offering advice on maintaining iteration rhythm and ensuring successful adoption.
The article examines software development efficiency from both human and technical perspectives, highlighting how overlooking human factors leads to failed automation attempts, illustrating the Hawthorne effect through a real experiment, and discussing immutable “physical” laws such as Moore’s law that shape productivity, ultimately offering practical actions to improve R&D performance.
Lean Software Development (LSD) is an agile framework that emphasizes delivering value and eliminating waste, offering principles and practices that streamline workflows, boost quality, enhance learning, and foster continuous improvement across software projects.
This article explains how limited resources shape product requirement prioritization, test‑bug grading, product‑module classification, online bug severity, and incident response levels, offering practical frameworks and concrete grading tables to help teams make objective, value‑driven decisions throughout a product’s lifecycle.
The article presents a comprehensive guide to essential Git commands, detailing their syntax, purpose, and typical usage scenarios, making it a practical reference for developers learning version control and command‑line operations.
This guide walks developers through five practical Git commands—stash, reset --soft, cherry‑pick, revert, and reflog—explaining their purpose, typical scenarios, exact syntax, and how to integrate them into daily workflows, plus tips for creating short Git aliases.
Discover a comprehensive guide to supercharging your Java development in IntelliJ IDEA, featuring 15 essential plugins, custom live templates, and global configuration tweaks that together can dramatically boost coding efficiency and code quality.
The article analyzes why big and medium‑sized companies often reinvent existing tools—due to unsatisfactory open‑source options, desire for technical prestige, low priority of requests, and skill development—and offers organizational strategies to evaluate, coordinate, and incentivize such efforts responsibly.
The article explains the concept, purpose, common criteria, necessity, potential risks, side effects, and best‑practice recommendations for using Definition of Ready (DoR) in agile teams, emphasizing that DoR should guide development without becoming an inflexible waterfall‑like gate.
This article traces the history of technical documentation from early computer manuals in the 1940s, through the emergence of markup languages like HTML and Markdown, to modern developer‑focused editors such as Yuque, highlighting why developers favor Markdown and the evolution of Yuque’s editor features.
This article examines GitHub Copilot’s code‑completion, comment‑driven generation, and repetitive‑task automation features, evaluates its accuracy and security concerns, and argues that while it can streamline mundane coding, it will not replace skilled programmers.
This article compiles all IntelliJ IDEA Windows shortcut keys, organized into 16 categories, and provides animated GIF demonstrations for over 90% of the shortcuts, enabling developers to quickly understand and apply each key combination to improve coding efficiency and navigation within the IDE.
This guide explains four popular Git workflows—Centralized, Feature Branch, Git Flow, and Forking—detailing their structures, advantages, and step‑by‑step commands so development teams can choose the right model for efficient, conflict‑free collaboration.
The article shares a former employee’s candid view of software development in a Chinese state‑owned enterprise, covering the prevalence of mandatory internal tools, heavy reliance on outsourced staff, outdated tech stacks, limited promotion routes, and the compensation structure that balances stable wages with modest bonuses.
This article introduces five emerging programming languages—Bhai-lang, Peregrine, Flix, Skip, and PolyCoder—detailing their origins, unique syntax rules, core features, and where to find their source code or playgrounds for developers seeking fresh, experimental tools.
Tencent’s 2021 R&D report uncovers a 41% rise in engineering staff, 6,000+ new projects, 3.2 billion added code lines, a surge in Go usage, extensive open‑source contributions, and a bold carbon‑neutrality roadmap, offering a comprehensive view of the company’s technical momentum and industry impact.
The essay debunks quick‑learning programming books, explains that true expertise requires years of practice, collaboration, and diverse language experience, and offers a concrete ten‑year roadmap for becoming a proficient software developer.
This article examines how defining and progressively moving the Definition of Done (DoD) within agile feature teams can clarify goals, reduce unfinished work, improve iteration completion and delivery rates, and ultimately increase development throughput through concrete metrics and practical steps.
The article outlines a three‑level indicator system that quantifies engineering quality across efficiency, quality, stability, and resource dimensions, using high‑level result metrics, detailed level‑2 breakdowns, and actionable level‑3 measures to enable drill‑down analysis, risk‑warning, and continuous, data‑driven improvement.
The article introduces a new R&D efficiency metric—throughput standard deviation—explains its statistical basis, shows how it was derived from annual reports, illustrates its application across multiple teams, and discusses practical insights and limitations for software development operations.
This article surveys the programming languages and technologies underlying a wide range of operating systems, user interfaces, desktop tools, databases, browsers, servers, and other software, illustrating how C, C++, Java, and other languages dominate different components across the software ecosystem.
An easy-to-understand guide explains what APIs and SDKs are, how they differ, and illustrates their roles with real‑world analogies and a case study of integrating a data‑upload SDK into an enterprise ERP system.
This article examines the evolution of low‑code development—from its roots in visual programming and early definitions to its booming market presence, major vendor offerings, industry challenges, security concerns, and future prospects—offering a balanced view of its potential and limitations.
The February TIOBE Programming Community Index shows Python reclaiming the top spot for the fifth time, highlights a shift from Alexa to Similarweb for data collection, and provides detailed rankings and trends for the top 100 programming languages, offering developers insight into language popularity and future considerations.
The article surveys 2022 software‑development forecasts, covering centralized and edge cloud infrastructure, multi‑cloud adoption, containers, security, blockchain, AI, low‑code, databases, big‑data engines, streaming, DevOps observability, programming languages, front‑end frameworks, and mobile development, offering a comprehensive outlook for practitioners and decision‑makers.
This article explains how git merge and git rebase both integrate commits from one branch into another, demonstrates their workflows with practical examples, compares conflict resolution methods, and outlines when to choose each approach based on team needs and history preservation.
This guide explains why traditional stash or multiple‑repo cloning fall short, introduces Git's worktree feature, and walks through adding, listing, removing, and pruning worktrees so developers can handle hotfixes and features in parallel without disrupting their main workflow.
A deep dive into the soaring demand for software talent in the UK, explosive cloud‑driven growth in China's telecom sector, and Microsoft's extended support for IE mode, highlighting how investment, remote work, and evolving web standards are reshaping the tech workforce.
The article examines how a steel‑plant technician built a nucleic‑acid‑test registration app in minutes using low‑code, analyzes the dramatic cost and speed advantages of low‑code over traditional development, and offers strategies for developers to adapt to this accelerating trend.
This article argues that Agile has become a buzzword while failing to deliver real value, highlighting ten fundamental flaws such as limiting agility to development teams, lacking automated testing, ignoring code and requirement quality, misusing staffing practices, treating Agile as a mere tool, and enforcing rigid functional divisions that together undermine true agility.
This article examines the 22 Python packages with the highest download counts on PyPI, explaining their functionality, popularity, and interdependencies, and provides practical code examples and usage tips, helping developers understand which libraries dominate the ecosystem and how they can be leveraged in real‑world projects.
The article humorously showcases a collection of the worst code snippets ever written, illustrating common pitfalls such as reinventing the wheel, magic numbers, unreadable variable names, misuse of booleans, and overly complex switch statements, while reminding developers that everyone writes imperfect code at times.
The IEEE Spectrum 2021 programming language ranking shows Python retaining the overall lead while C# jumps dramatically to sixth place, highlighting shifts in developer demand across web, enterprise, mobile, and embedded domains based on data from eight major sources.
This guide provides a comprehensive, step‑by‑step walkthrough of Git’s core commands—including add, commit, reset, checkout, diff, merge, cherry‑pick, and rebase—illustrated with diagrams and practical examples to help developers understand version‑control workflows and avoid common pitfalls.
This comprehensive guide explains what bug tracking is, outlines effective workflows, lists essential features, compares top bug‑tracking tools—including BugHerd, Bugzilla, MantisBT, Jira, and more—while highlighting each tool's advantages, disadvantages, integrations, and pricing to help teams choose the right solution.
The IEEE Spectrum 2021 programming language ranking shows Python retaining the top spot across overall and multiple sub‑rankings while Microsoft’s C# jumps from 23rd in 2020 to 6th in 2021, reflecting shifting industry demand and emerging trends.
This article humorously showcases a curated collection of notoriously bad code snippets, illustrating common pitfalls such as misuse of boolean logic, magic numbers, poorly named variables, and overly complex switch statements, while encouraging developers to reflect on and improve their coding practices.
The article explains how a collaborative effort by CAICT and more than 30 leading tech and financial companies created the most comprehensive DevOps efficiency measurement model, detailing its components, evaluation results, and upcoming assessment enrollment for enterprises seeking to boost software development performance.
This article outlines ten practical habits for developers, from relying on official documentation and thorough testing before delivery to effective logging, mastering Git, prioritizing functional implementation over premature optimization, managing requirements, proactively solving project issues, allocating buffer time, hands‑on learning, and improving English for technical growth.
This article explains the fundamental differences between Continuous Integration (CI) and Continuous Delivery/Deployment (CD), outlines why CI is a team issue, describes essential checks, emphasizes tool‑agnostic practices, and provides guidance on building efficient CI/CD pipelines to improve software delivery speed and reliability.
The CodeLani author shares a continuously updated catalog of 4,248 programming languages, detailing each language's name, type, and birth year, while noting controversies over included libraries and protocols and inviting contributions via GitHub.
This article explains how to locate and restore accidentally deleted source files by using various git log options, analyzes why the deletion went unnoticed during code review, and suggests preventive measures to automatically detect similar issues in the future.
Mastering programming goes beyond code; this article outlines ten practical habits—from consulting official documentation and thorough testing to effective logging, Git mastery, prioritizing features, managing requirements, proactive problem solving, realistic scheduling, hands‑on learning, and improving English—that help developers become reliable and efficient.
This article analyses the current state of China's industrial software—covering EDA, CAD, and CAE markets—highlighting domestic market shares, the dominance of foreign giants, development difficulties, misconceptions, and the key factors that hinder the growth of home‑grown solutions.
This article lists the seven programming languages that command the highest average salaries in the United States in 2021, explaining each language's strengths and why they are in strong demand among employers.
This article shares a former full‑stack developer’s journey into freelance work, covering background, motivation, client channels, realistic income, a simple pricing formula, diverse tech stacks used, work‑life balance, and practical advice for programmers considering a side‑gig or full‑time freelancing.
This article outlines ten practical habits for developers, from relying on official documentation and thorough testing to effective logging, Git mastery, prioritizing functionality, handling ambiguous requirements, proactive problem‑solving, scheduling buffers, hands‑on learning, and improving English for better access to technical resources.
DPVS v1.9.0, the latest open‑source four‑layer network load balancer from iQIYI, now fully supports DPDK‑20.11 LTS, offers streamlined compilation, universal flow management, dynamic mbuf fields, enhanced per‑core scheduling and UDP health checks, and has been running stably in production for three months.
Software quality is often seen as a trade‑off with cost, but Martin Fowler argues that higher internal quality—clean architecture, modular code, and reduced cruft—lowers future development expenses, speeds feature delivery, and ultimately makes high‑quality software cheaper to produce despite short‑term effort.
On November 22 the Rust language review team announced a collective resignation in protest of the core team's lack of accountability, sparking intense debate about open‑source governance, prompting four concrete recommendations, a temporary replacement group, and broader reflections on Rust’s popularity and community principles.
This article shares ten practical habits for developers, from consulting official documentation and thorough testing before delivery to effective logging, mastering Git, prioritizing functional implementation, managing requirements, proactively solving project issues, allocating buffer time, hands‑on learning, and improving English for better access to technical resources.
The article analyses why Chinese B2B cloud firms, despite long working hours and abundant talent, lag behind US providers, attributing the gap to product‑driven versus sales‑driven strategies, cultural differences, incentive structures, and low willingness to pay for high‑quality solutions.
This article explains what unit testing is, how to implement it with frameworks like Spock, provides a simple Groovy example, and discusses the advantages and drawbacks of unit tests for software development.
This article surveys the most popular software development laws and principles—such as the Pareto, Broken Window, Occam's Razor, Dunning‑Kruger, Peter, Parkinson, Hofstadter, Conway, Murphy, Brook, Postel, Kerckhoffs, Linus, Wirth, and Knuth principles—explaining each rule and offering practical ways to apply or avoid them in real‑world development work.
The article explains how to validate and review software requirements through effectiveness, consistency, completeness, realism, and testability checks, describes the role of requirement reviews and prototyping in reducing rework costs, and outlines how to generate test cases that ensure requirements are testable and verifiable.
The article presents a curated list of the 2021 InfoWorld BOSSIE award winners, describing 29 open‑source projects ranging from front‑end frameworks like Svelte to cloud‑native tools such as Minikube, data‑science libraries like Dask and MLflow, and AI explainability packages including InterpretML and Lime, each with brief functional overviews and GitHub links.
The article defines delivery capability as the ability to provide usable, complete results, explains why thorough delivery matters, and outlines concrete delivery standards for backend, frontend/mobile, and QA roles to achieve high‑quality, end‑to‑end software outcomes.
The article humorously outlines a step‑by‑step workflow for fresh graduates tackling a new coding task, from choosing tools and drafting a technical plan to rapid development, code reviews, testing, and deployment, while emphasizing flexibility and the unpredictable nature of backend work.
The article outlines seven common behaviors that reveal a programmer’s lack of experience—such as massive one‑off commits, poor code quality, multitasking, arrogance, ignoring feedback, handling personal matters at work, and chasing every tech trend—and offers practical steps to become more professional and productive.
Low-code development is gaining momentum, and this article compiles a curated list of 17 open-source low-code and no-code platforms—including Saltcorn, Joget DX, Digdag, Stackstorm, CUBA Platform, Skyve, and others—detailing their key features, licensing, and repository links for developers seeking rapid application building solutions.
Understanding the seven common habits—such as massive code commits, poor code quality, multitasking, arrogance, ignoring feedback, handling personal matters at work, and chasing every tech trend—helps developers recognize unprofessional behavior and adopt practical strategies to improve productivity and advance their software engineering careers.
The article examines the November 2021 TIOBE index, highlighting PHP's slip from the top ten, the rise of languages like Ruby, Groovy, Lua, Dart, and Kotlin, and discusses PHP's modern strengths, community support, and remaining drawbacks for backend development.
