The article shows how developers can describe desired UML, flowchart, SVG icon, or mind‑map in natural language and use AI to generate PlantUML or Mermaid code instantly, streamlining diagram creation, reducing manual effort, and illustrating broader AI‑assisted productivity tips for software development.
The article explores how generative AI and large language models are enabling automated code creation, self‑repair, and continuous‑integration workflows, while highlighting challenges in code quality, industry experiments at Google and Stack Overflow, and the future impact on developers and software engineering practices.
This guide explains common character encodings such as ANSI, ASCII, GB2312/GBK/GB18030, Unicode, UTF‑8, UTF‑16, and UTF‑32, and shows how to handle them in MFC and Qt with practical code examples.
Reading other people's code is essential for improving programming ability, debugging speed, code style, and collaboration, and this guide explains why it matters and provides practical, step‑by‑step strategies for choosing, analyzing, and learning from source code.
The article explains that viewing testing as a mindset is essential for developers, outlines how to decide what to test—through user journeys, new features, and bugs—compares manual and automated testing, discusses the shift of testing responsibilities leftward, and clarifies who should own testing within various team structures.
This article chronicles the life and career of Guido van Rossum, the creator of Python, detailing his early fascination with computers, the birth of Python in 1989, its evolution across various domains, his roles at Google and Dropbox, retirement, and recent return to Microsoft, while also offering a free Python learning resource.
This article introduces the 2023 developer roadmaps from roadmap.sh, offering detailed visual guides for frontend, backend, and DevOps technologies, explaining how these structured paths can help programmers learn efficiently, avoid blind trial‑and‑error, and access high‑resolution images and related resources for each stack.
The article shows how AI large‑language models such as ChatGPT can support every stage of the software development lifecycle—from extracting requirements and designing solutions to generating code, tests, deployment scripts, and operational diagnostics—while warning about model inaccuracies, hallucinations, intellectual‑property and privacy risks.
The 2023 GitLab DevSecOps survey of over 5,000 IT leaders, CISOs, and developers across multiple industries reveals heightened security focus, growing AI/ML use in testing, and persistent tool‑chain management obstacles that hinder productivity and compliance efforts.
The article explains that many core components of modern computing—operating systems, network stacks, compilers, drivers, and runtimes—are written in C/C++, making the language essential for infrastructure, but because reinventing these complex systems is impractical, beginners often shift to higher‑level languages for application development, illustrated with a Lego analogy.
The article demonstrates how ChatGPT‑4 outperforms its predecessor in logical reasoning and code generation, helping developers craft regexes, refactor Go functions, implement business logic, fix parsing bugs, and suggest clearer names, while rapidly producing unit tests and accelerating low‑risk development tasks without fully replacing engineers.
This article explains why Site Reliability Engineering (SRE) and DevOps are both essential for modern software development, compares their objectives, outlines their complementary roles, and highlights the fundamental differences that help organizations achieve faster releases with higher reliability.
This article compares Java and embedded development from salary, career development, and entry‑level difficulty perspectives, concluding that Java offers higher short‑term pay while embedded provides more stable, long‑term prospects for those willing to invest in extensive learning.
The article analyzes how unnecessary meetings, early-stage overstaffing, and fragmented work schedules waste valuable human capital, explaining the underlying motivations, consequences for team productivity, and offering insights on more efficient project and time management practices.
The article explains why Go has entered the TIOBE top‑10, highlighting its built‑in concurrency, garbage collection, static typing, Google backing, and its role in projects like Docker and Kubernetes, while describing how the TIOBE index is calculated and how it can guide language selection decisions.
The article compares traditional software project teams with product‑mode teams, highlighting how long‑lived, cross‑functional product teams improve responsiveness, reduce cycle time, preserve knowledge, maintain architectural integrity, and deliver higher business value through continuous iteration and ownership.
The article introduces a comprehensive DevOps efficiency measurement model jointly created by CAICT and over 30 leading tech companies, detailing its maturity and tool components, evaluation process, benefits for enterprises, and the upcoming registration timeline for participation.
This article explains what unit testing is, provides C# code examples for a simple calculator, and discusses four reasons why automated unit tests should run in CI/CD pipelines to improve development speed, prevent regressions, and protect code written by other developers.
The article explains what user stories are, outlines five frequent mistakes—misunderstanding them as requirements, treating them as contracts, making them too large, undervaluing small stories, and creating unnecessary dependencies—and offers practical tips for crafting concise, value‑focused stories in agile software development.
The article explains how software and the Internet have transformed business operations, why adopting DevOps practices is essential for modern companies, and introduces Jenkins as a key tool for automating the entire CI/CD pipeline from code commit to production deployment.
The 2022 China Enterprise Agile Practice Whitepaper, based on a survey of 644 companies across 43 cities and 16 industries, uncovers how agile adoption has surged, highlights dominant frameworks like Scrum of Scrums, identifies key engineering practices, and pinpoints organizational culture as the biggest hurdle for Chinese firms navigating digital transformation.
Despite sensational claims that GPT will eliminate programmers, this analysis argues that AI will reshape rather than eradicate the profession, emphasizing the need for developers to adopt full‑stack and low‑code skills, diversify into business and management roles, and adapt to evolving market demands.
Many job ads demand proficiency in specific languages, but true mastery is unattainable; programming languages are merely tools, and software developers should be seen as problem‑solvers rather than language‑specific specialists, with skills that transfer across languages and focus on creative problem solving.
This article identifies the eight most frequent errors junior developers make—from misunderstanding business needs and neglecting testing to ignoring security and failing to keep learning—and offers practical advice on focusing on problem solving, effective communication, and continuous skill improvement.
In the post‑pandemic tech surge, developers are turning to emerging languages, and this article highlights the top five—Java, R, SQL, CSS, and C/C++—that are rapidly gaining popularity and may soon surpass Python in demand across various development domains.
This article explores four distinct fine‑tuned LLaMA/ChatGLM approaches for AI‑assisted code generation—example‑based, test‑driven, metadata‑augmented, and information‑matching—detailing their training data, prompts, sample inputs and outputs, and evaluating their strengths, limitations, and suitable application scenarios.
This article outlines ten key habits—writing clean reusable code, understanding business impact, listening before speaking, maintaining discipline, focusing on the right tasks, persisting with problem‑solving, seeking help, expanding expertise, staying open to new ideas, and pushing beyond comfort zones—that distinguish top‑performing developers from their peers.
The article examines how ChatGPT automates many manual tasks, reducing demand for translators, editors, customer support reps, and data analysts, while boosting opportunities for chatbot developers, NLP engineers, data scientists, content creators, and software developers, and outlines broader industry advancements driven by AI.
This article examines how ChatGPT’s rapid advances in natural‑language processing spark fears of job loss among developers, explains why many routine coding tasks are vulnerable, and highlights why programmers’ creative problem‑solving, debugging, and system design keep their roles secure while offering productivity benefits.
This article explains why software developers need solid project management skills, outlines common pain points such as inaccurate effort estimation, dependency delays, and quality‑efficiency trade‑offs, and provides practical guidance on progress, quality, and risk management—including work breakdown, dependency handling, code review, testing, logging, and risk mitigation—to help engineers deliver projects on time, with high quality, and with minimal surprises.
Tencent’s 2022 R&D report shows that three‑quarters of its staff are developers, with over 7,000 new projects, 29.4 billion new code lines, and a 60 % reduction in build time after moving to cloud‑native DevOps, while Go tops language usage and open‑source contributions exceed 80 %.
This article outlines ten essential characteristics of high‑quality code—robustness, efficiency, simplicity, brevity, testability, reusability, portability, observability, operational readiness, and scalability—illustrates common bad‑code examples, and explains how thorough requirement analysis, design, testing, and continuous iteration produce maintainable, reliable software.
The article humorously lists twenty counterproductive coding “tips” – from using single‑letter variables and omitting comments to writing one‑line code, ignoring errors, creating unused variables, deep nesting, and skipping tests – claiming these practices boost productivity despite harming readability and reliability.
The article teaches developers essential project‑management skills—schedule, quality, and risk management—by explaining why coordination matters, outlining common pain points, and detailing practical techniques such as two‑day task decomposition, code‑review standards, and systematic risk identification and mitigation to become reliable, results‑driven partners.
This article compiles a comprehensive overview of the programming languages and technologies underlying major operating systems, graphical interfaces, desktop search tools, office suites, databases, web browsers, email clients, IDEs, virtual machines, ERP systems, business intelligence, graphics software, search engines, websites, games, 3D engines, server software, and other applications.
Drawing from years of development work, the author explains why programmers rarely venture into solo entrepreneurship, highlighting challenges in technology, project acquisition, company formation, hiring, product development, and personal stability, and offering practical insights for anyone considering the leap.
The article examines software development efficiency by defining R&D effectiveness, discussing organizational design, architectural alignment, project management practices, and key performance metrics, and concludes with actionable implementation steps for building high‑performing engineering teams.
This article outlines twelve essential software testing principles—ranging from user‑centric testing and lifecycle integration to risk‑based prioritization and third‑party verification—while also announcing the IDCF DevOps Hackathon, a 36‑hour event in Shanghai for building and launching a product.
Li Yang’s article traces high‑level programming languages from Fortran and Lisp in the 1950s through C, Java, Python, and modern Rust, Go, Kotlin, and Swift, highlighting shifts toward object‑orientation, safety, readability, cross‑platform support, and the emerging influence of AI‑assisted code generation on future language design.
The article explains the distinction between defined and high‑uncertainty work, outlines traditional waterfall planning versus adaptive agile approaches, compares their processes, costs, and success rates, and presents data from the Standish Group showing agile projects outperform waterfall ones.
GitHub’s February 14 update introduces a stronger AI Codex model, Fill‑In‑The‑Middle context handling, and lightweight client improvements that raise code suggestion quality, cut response time, and add real‑time security filtering, while enterprise Copilot now offers VPN support and easy licensing for thousands of developers.
The article argues that while agile coaches do not need deep technical expertise, they must possess sufficient technical understanding to build trust, conduct effective team assessments, and guide agile transformations, and it also outlines the knowledge areas a management‑focused agile coach should master.
This article compares DevOps and FinOps, outlines their ten major differences, and explains how integrating the two practices can create a more efficient and financially optimized software development lifecycle.
This article explains how architecture remains a vital part of agile software development, covering agile‑first approaches, lifecycle‑wide modeling, ownership roles, scaling strategies, demand‑driven design, multi‑view modeling, and practical tips for communicating and evolving architecture without over‑building.
The article explains how agile development reshapes testing responsibilities—emphasizing customer mindset, continuous testing, strategy formulation, and exploratory testing—while also announcing the IDCF DevOps Hackathon, an end‑to‑end DevOps experience event in Hangzhou as this event.
This article explains the three major software development models—Waterfall, Agile, and DevOps—detailing their origins, characteristics, advantages, and challenges, and shows how they evolved to meet the fast‑changing demands of modern internet enterprises.
This article examines why relying solely on Java limits a developer's perspective, traces the historical development of programming languages from assembly to modern multi-paradigm languages, and argues that learning new languages each year expands one’s mental models and problem‑solving abilities.
This article details HaiTong Securities' journey through the DevSecOps assessment, showcasing their eHaiTongCai data service platform, interview insights from senior managers, the security challenges they faced, and the concrete steps they took to embed security across the entire software lifecycle.
The TIOBE Index named C++ the 2022 Language of the Year, highlighting its market‑share surge, the rise of Rust and other languages, and expert opinions on why C++ remains a high‑performance choice despite growing competition from newer languages.
In this interview, Liu Lei, General Manager of the Bank of Communications Software Development Center, explains how three flagship projects passed the DevOps Continuous Delivery Level‑3 assessment, detailing the standards, metrics, tooling improvements and the broader impact on the bank’s digital transformation.
The article examines how testers often become scapegoats in software projects, detailing three layers of blame—from missed delivery schedules and unmet quality expectations to emergency releases—while arguing that underlying architectural and design flaws, not testing, are the true sources of product defects.
In this interview, NetEase Cloud Commerce CTO Yin Jingcheng shares his 14‑year journey, stages of technical leadership, practical advice for new managers, strategies for balancing coding and management, and actionable guidance on fostering efficient, innovative R&D teams across business cycles.
The article argues that many organizations are exhausted by the over‑hyped Agile movement, labeling it an "Agile industrial complex," and calls for a return to the Agile Manifesto’s core values and principles, enriched by insights from social sciences and interdisciplinary thinking.
This article compiles an extensive list of operating systems, graphical interfaces, desktop search tools, office suites, databases, browsers, email clients, IDEs, virtual machines, server software, and many other applications, highlighting the programming languages—primarily C, C++, and occasionally assembly or Java—used to develop each of them.
This article provides a comprehensive visual tutorial on Git’s core commands—including add, commit, reset, checkout, diff, merge, rebase, and cherry‑pick—explaining their effects on the working directory, staging area, and repository while illustrating concepts such as HEAD, branches, and detached states.
The article analyzes why software development teams often see productivity drop as headcount grows, explains communication‑cost theory, introduces a 5S model covering design, development, testing, management and support stages, and recommends enterprise architecture and domain‑driven design to curb complexity and boost delivery speed.
The November TIOBE index shows Rust climbing into the top four while Python, C, Java and C++ maintain growth, presents the full Top 20‑50 language list, details the 51‑100 entries, and includes historical and celebrity rankings to illustrate long‑term popularity trends.
The article outlines five common detrimental habits of programmers—unstandardized code, reluctance to learn, poor teamwork, rejecting constructive feedback, and avoiding post‑mortem reviews—explaining why they hinder career growth and offering practical advice to cultivate humility, continuous learning, and effective collaboration.
The article explains why Scrum may not be appropriate in many situations, outlines the essential conditions for its successful use, and provides concrete examples of environments where Scrum works well and where it tends to fail, helping teams assess its applicability.
This article guides R&D team leaders through the mindset, stages, implementation steps, application patterns, common challenges, and future directions for adopting low‑code platforms to reduce costs, improve efficiency, and solve specific business problems.
Feng Di, Xiaohongshu’s community technology leader, explained that an outstanding engineering team thrives on passion, freedom, and efficiency, must manage endless product demand, scale without excessive process, cultivate T‑shaped skills, balance algorithm work with solid system engineering, adopt data‑driven ownership, automated testing, and meaningful overtime to continuously solve real problems together.
This article explains the ten advantages of using fixed‑length agile iterations—such as better forecasting, risk control, reduced waste, and improved alignment—while highlighting common pitfalls like extending iterations, treating them as mere timelines, and unstable team composition, emphasizing the prerequisites needed to reap these benefits.
This article explores Elon Musk’s early fascination with computers, his self‑taught mastery of BASIC, the creation of his first game Blastar, and how his programming skills helped launch ventures like Zip2, X.com, and ultimately shaped his entrepreneurial success.
The article explains the four‑hold principles from Continuous Delivery 2.0—doing less, continuously decomposing work, constantly gathering feedback, and pursuing ongoing improvement—and shows how applying them can eliminate late‑night release cycles, improve DevOps feedback loops, and strengthen R&D management in software projects.
This reflective essay explores how a love for coding, perfectionist mindset, continuous curiosity, and user focus shape a programmer's career, offering practical advice on mastering the craft, balancing art and engineering, and achieving bug‑free, impactful software.
This article explores why software development timelines consistently exceed estimates, detailing factors such as project size, missing design documentation, overlooked management tasks, testing, and the challenges of scaling estimation methods from small to medium and large projects.
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.
