This article outlines fifteen common hidden requirement types—from detail tweaks and cross‑platform adaptations to scalability, security, and content‑operation needs—and offers practical strategies for developers and product teams to anticipate, design for flexibility, and reduce costly changes during development.
This article shares twenty practical software development lessons—from starting with a minimal version and iterating, to effective debugging, teamwork, and continuous learning—offering actionable guidance that seasoned programmers have distilled over more than a decade of experience.
The author recounts a twenty‑year programming odyssey that began with BASIC on a red‑white game console, continued through school computers, university projects, BBS robots, early web startups, and modern cloud services, reflecting on the joys, frustrations, lessons, and personal growth experienced along the way.
The article explores why programmers obsess over programming languages, discussing rankings, community dynamics, conference culture, and the professional impact of mastering multiple languages, while also offering resources for staying informed about language trends.
The article reveals how algorithm engineers spend most of their time on data cleaning, manual feature engineering, and business integration, exposing a gap between the glamorous perception of the role and the gritty, data‑centric work that actually defines it.
In this interview, senior manager Liang Yonggang of Dongfang Hongtai discusses his company's background, recent eSDK training on UC/IVS/TP, the benefits and shortcomings of the program, suggestions for the eSDK WeChat channel, and valuable software development and project management lessons he has gathered over a decade in the industry.
The article presents a collection of thirty‑five core observations from the classic 1984 book “Hackers: Heroes of the Computer Revolution,” highlighting hacker philosophy, attitudes toward openness, control, creativity, and the social impact of computing.
Drawing on three decades of software development, this article shares sixteen practical lessons about client interaction, security, code simplicity, continuous learning, and evaluation that can help programmers and teams make better decisions and avoid common pitfalls.
This article examines whether programmers face an age ceiling, compares them with veterans in other fields, analyzes different company types, and offers strategies for maintaining value and relevance throughout a long software development career.
This article explains five common types of programming comments that hinder readability—such as self‑promoting tags, outdated code blocks, redundant explanations, irrelevant stories, and lingering TODOs—and offers practical advice on how to avoid them.
The article outlines essential habits for developers—including cautious acceptance of tasks, strategic refusal of unreasonable requests, building a personal knowledge framework, maintaining a big‑picture view, adhering to coding standards, conducting code reviews, learning business domain, and persisting with good practices—to become a high‑performing programmer.
A seasoned CTO shares six recurring problems—from unfamiliar tools and over‑planning to poor stack choices and ignored patterns—offering practical advice on fostering learning, focusing on MVPs, encouraging code reuse, and promoting continuous development within engineering teams.
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.
This article examines Docker’s broader value compared to Java and Linux, arguing that its indirect enhancements to development, testing, and operations improve efficiency and reduce communication costs, ultimately offering greater organizational benefits than traditional technologies.
This article explains why version control is indispensable for software projects and offers three practical Git recommendations—track all artifacts, commit frequently with appropriate granularity, and write clear commit messages—to improve collaboration, maintainability, and deployment across development environments.
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 offers ten actionable strategies—overcoming inertia, following experts, building a knowledge network, consuming diverse media, taking action, blogging, feeling the tech pulse, attending meetups, embracing GitHub, and focused learning—to help anyone efficiently master new technologies in the software field.
The Unix grep command, created by Ken Thompson before the fourth edition of Unix and named after the ed editor’s “g/re/p” syntax, first appeared in Version 4, later expanded by Al Aho into egrep and fgrep, and was popularized through the GNU and BSD implementations, illustrating Unix’s collaborative evolution.
The article traces the ten‑year evolution of the Agile Manifesto, examines the perspectives of its signatories and industry experts, compares Scrum, XP, Kanban and RUP, and discusses the challenges and conditions required for successful Agile adoption in modern software projects.
The author shares the story of launching the Onepay open‑source tip button on GitHub, explains core Git concepts such as distributed repositories, branching and forking, and reflects on why open‑source collaboration outweighs closed‑source models for technological progress.
An analysis of software release delays reveals that uniform developer productivity, vague or changing requirements, and disruptive task handoffs—rather than programmer slowness—are the primary culprits, and offers practical steps for managers to improve workflow.
The article argues that the perceived trade‑off between development speed and code quality is a misleading premise, explaining how short‑term shortcuts harm long‑term productivity while disciplined, high‑quality practices actually accelerate delivery and improve product outcomes.
The article humorously categorizes programmers into eight distinct “extreme” types—ranging from the single‑technology‑obsessed to the isolated code‑only worker—illustrating each stereotype with vivid descriptions, typical remarks, and illustrative images.
This article compiles a selection of concise open‑source projects—each typically under 5,000 lines of code—spanning JavaScript modules, Node.js frameworks, Python tools, Emacs utilities, C libraries, databases, web servers, and more, offering beginners practical codebases to study and learn from.
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 article showcases the top ten most memorable and humorous code comments harvested from a StackOverflow discussion, ranging from sarcastic warnings and epic motivational messages to absurd exception handling and playful macros, illustrating how developers inject personality into code while inviting readers to share even funnier examples.
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.
This guide compiles a comprehensive list of free and paid online programming resources—including interactive games, university courses, MOOCs, and coding bootcamps—to help beginners and intermediate learners quickly acquire coding skills across various languages and platforms.
This curated collection, maintained by fffaraz, enumerates a comprehensive range of C++ frameworks, libraries, and resources—including the standard library, web and GUI frameworks, AI, networking, graphics, audio, databases, cryptography, machine learning, concurrency, serialization, build tools, IDEs, and debugging utilities—for developers seeking ready‑made solutions.
Looking ahead, programmers may see GPUs supplant CPUs, databases handle complex analytics, JavaScript dominate browsers and servers, Android power every device, the Internet of Things expand, open‑source ecosystems seek sustainable funding, CMS tools become richer, plugin‑centric development replace monolithic coding, command‑line interfaces endure, education strives for true simplification, outsourcing battles automation, and managers risk growing technically illiterate.
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.
A former video editor turned construction worker shares his personal journey, challenges, and step‑by‑step advice for anyone over 25 who wants to break into software development, including building small apps, contributing to open source, attending meetups, and mastering interview fundamentals.
This tutorial explores advanced Git techniques—including auto‑completion, .gitignore usage, blame, log options, reflog, partial staging, interactive rebase, stash, fsck, and cherry‑pick—providing clear commands, examples, and screenshots to help developers manage repositories more efficiently.
The article provides a detailed, data‑driven look at Google’s internal software development practices, covering unified trunk code management, pervasive code visibility, rigorous reviews, feature‑flag experimentation, strict testing, and the blend of Java, C++, and JavaScript in front‑end and back‑end work.
After two years as an intern and eight months as a full‑time engineer at Microsoft Azure, I reflect on nine often‑overlooked corporate practices—from missing documentation and low enthusiasm to limited code review and reliance on outdated tools—that shape daily life for developers in large tech firms.
The article critiques common careless attitudes toward code reviews, exposing how pointless debates, condescending comments, exhaustive checklists, and rigid pass‑fail policies hinder collaboration, and offers practical, fact‑based strategies—including constructive questioning and pair verification—to transform reviews into productive, bug‑reducing discussions.
After weeks of puzzling over intermittent socket disconnections in a persistent‑connection server, the author finally traced the fault to a missing timeout/notification when the remote service drops while awaiting an authentication code—a revelation sparked by a noisy office party, a spilled cola, and a missed elevator.
Google’s development culture blends full‑stack engineering with universally visible code stored on a single trunk, relies on strict style and unit‑test enforcement, feature‑flag toggles instead of branches, minimal third‑party libraries, server‑side templating and GWT/Dart for front‑end, and data‑driven, heavily reviewed workflows that other firms might emulate.
