This article explores practical programming philosophies for writing robust, maintainable code by using exhaustive two‑branch if statements, proper error handling, disciplined null‑pointer management, and avoiding over‑engineering, offering concrete examples and guidelines for Java and other languages.
This article discusses practical approaches to organizing a React project, comparing single‑file setups with modular multi‑file structures, component directories, testing strategies, data handling, and view integration, emphasizing pragmatic, maintainable architecture over rigid conventions.
These ten detrimental coding habits—ranging from misspelled identifiers and poor formatting to hard‑coded passwords and premature optimization—illustrate how bad practices can reduce efficiency, increase bugs, and jeopardize security, emphasizing the need for disciplined, modular, and well‑structured development.
This article compiles a comprehensive list of must‑have web development skills—including UI/UX best practices, security measures, performance optimization, SEO techniques, core technical knowledge, and bug‑fixing strategies—to help developers build robust, user‑friendly websites.
Learn a comprehensive set of 30 practical PHP best‑practice tips covering file inclusion, path handling, debugging, output buffering, security, performance, database interactions, session management, and code organization to improve maintainability, efficiency, and reliability of your backend applications.
This article explains why clear, self‑describing naming and adherence to coding conventions are essential for readable, maintainable software, illustrating common pitfalls with bad examples and showing improved alternatives that convey intent without relying on comments.
This article explains why clear, self‑describing naming is essential for professional programmers, illustrates common pitfalls with bad examples, and provides concrete guidelines on intent‑revealing, unambiguous, appropriately‑sized, convention‑compliant, domain‑aware names to improve code readability and collaboration.
This article shows how to transform fragmented PHP snippets—such as disjointed loops, scattered timing code, and split error‑code definitions—into cohesive, readable structures using for‑loops, functional helpers, shutdown callbacks, and modern constant arrays, improving both aesthetics and maintainability.
A community discussion weighs the benefits and drawbacks of upgrading Oracle 10gR2 to 11g, sharing real‑world experiences, technical pitfalls like ORA‑24247, alternative viewpoints, and guidance for DBAs deciding whether the upgrade is worth the effort.
This article outlines six practical habits for developers—self‑checking code before blaming tools, continuous learning, embracing refactoring, acting professionally, using static analysis, and genuinely caring about code quality—to improve productivity and reduce bugs in any software project.
The article offers practical guidance for programmers on when to say Yes or No, how to construct a personal knowledge system, develop a big‑picture view, follow coding standards, conduct code reviews, learn business knowledge, and maintain disciplined habits for continuous growth.
This article explains why using SELECT * is problematic and demonstrates a simple technique—adding a computed column that triggers a divide‑by‑zero error—to block SELECT * queries while still allowing column‑specific selections.
The article explores the definition of a programmer, outlines essential skills and daily responsibilities, discusses common career pitfalls, and provides practical advice on personal branding and professional growth for software developers.
A graduate student recounts the shocking code quality issues he found in his team's data‑mining project, highlighting bad naming, massive classes, duplicated logic, overuse of singletons, excessive comments, and other anti‑patterns that jeopardize maintainability and graduation.
Copy‑pasting outdated Nginx‑PHP tutorials often introduces hidden bugs, so this article explains typical configuration mistakes, the inheritance model, misuse of directives like index, if, and fastcgi_params, and provides a streamlined, secure configuration example.
This guide explains why good naming is essential for maintainable C++ code, presents eight concrete principles—such as being true to the name, avoiding misleading terms, using searchable identifiers, and leveraging meaningful context—and shows bad versus good examples for variables, functions, classes, and constants.
This article presents eighteen core programming principles—from DRY and KISS to the Open/Closed and Law of Demeter—that help developers write cleaner, more maintainable code, reduce bugs, and adapt to change effectively.
This article outlines the most frequent programming errors beginners make—such as mindlessly copying code, reinventing the wheel, over‑relying on Google, ignoring warnings, and opting for quick fixes—explaining why they harm code quality and how to avoid them.
This talk shares the experience of a small machine‑learning team at Dangdang, describing how they built a recommendation system from scratch, the tools and processes they used, the challenges of limited personnel, and the many pitfalls they encountered while iterating toward a production‑ready solution.
The article emphasizes that programmers achieve the software engineering iron triangle of cost, speed, and correctness by thoroughly understanding problems, crafting clear designs, listing test conditions, considering impacts on other components, and anticipating future issues, urging a slower, long‑term perspective before diving into code.
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.
This article offers practical, step‑by‑step advice for newcomers on how to efficiently explore, understand, and navigate large codebases by focusing on file structure, incremental reading, note‑taking, and targeted deep dives while avoiding common pitfalls.
The article argues that strict coding standards often hinder creativity and teamwork, explaining why the author abandoned them in favor of trusting developers' judgment and focusing on results rather than imposed rules.
This article provides a comprehensive checklist for code reviewers, covering formatting, design, readability, functionality, security, testing, performance, and resource usage, while explaining why many of these aspects can be automated and how to balance manual inspection with tooling.
This article presents a comprehensive set of logging best‑practice rules—from defining log levels and classifications to using RequestIDs, monitoring alerts, and managing log size—aimed at improving system reliability, troubleshooting speed, and operational efficiency.
To accelerate your career as a newly minted software engineer, adopt the four critical habits of the top 1%: investing in learning and tooling, taking decisive action, acting immediately, and maintaining full‑stack understanding, which together enable rapid, high‑impact contributions.
This article outlines ten frequent web developer pitfalls—from outdated HTML and browser‑specific code to slow performance and excessive page reloads—explaining their impacts and offering practical solutions such as modern semantic markup, cross‑browser testing, image optimization, responsive design, and automated tooling.
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 explains how to formulate technical questions so that experienced hackers and community members are more likely to provide helpful answers, emphasizing prior research, clear presentation, humility, and demonstrating effort to avoid being perceived as a 'loser' who merely demands solutions.
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 reflects on an engineer's experience updating a signature system, highlighting the pitfalls of quick patches, the importance of requirement analysis, resource testing, realistic time estimation, and proactive communication, and advocates for a refactor to improve maintainability and role perception.
This article explores the stages of programming expertise, defines what makes an expert in software engineering, and offers practical daily habits and mindset shifts that can help developers transform from competent coders into truly great professionals.
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 explains the definition of operational standardization and outlines four core principles—best practice, modularity, templating, and simplicity—showing how they improve team efficiency, documentation consistency, and enable scalable, automated operations.
This article shares nine practical PHP tips—from security fundamentals like input filtering and output escaping, to efficient coding tricks such as using ternary operators, caching, and modern frameworks—aimed at helping developers write safer, cleaner, and faster backend code.
The article shares practical support and communication principles, data handling guidelines, and internal best‑practice examples from Qunar to help newcomers avoid common pitfalls and improve operational efficiency by emphasizing sincere assistance, careful treatment of sensitive information, post‑mortem reviews, and appropriate use of tools such as mailing lists, QTALK, and encoding conversion.
This article presents ten practical Redis tips—from avoiding the costly KEYS * command and using SCAN, to leveraging hashes, setting expirations, choosing proper eviction policies, handling errors, scaling with clusters, and ensuring high availability with Sentinel—helping developers optimize performance and reliability.
A humorous story about a graduate student’s unreadable code illustrates why naming is the toughest programming challenge, and the article then outlines six clear principles—avoiding metaphors, keeping names short, shortening expressions, using active voice, steering clear of jargon, and breaking rules when necessary—to improve code readability and maintainability.
This article compiles ten provocative programming viewpoints—from the primacy of using your brain over rigid best‑practice checklists to the limits of unit testing—offering practical reflections on mindset, learning, tooling, and design that can sharpen any developer’s approach.
This article offers goal‑oriented, data‑driven advice and checklists for architecture refactoring, emphasizing realistic technology selection, pressure management, business understanding, handling non‑technical influences, code‑quality practices, and team readiness to ensure effective, sustainable redesigns.
This guide shares ten practical fault‑management techniques—ranging from proactive attitude and prioritizing incidents to continuous follow‑up and team collaboration—to help operations teams reduce damage, maintain service reliability, and keep users engaged during outages.
The article shares a comprehensive set of development and operational best‑practice guidelines from Qunar’s internal wiki, covering URL testing, HTML validation, API documentation, security checks, logging, encoding, teamwork, and transparent change management for engineers.
The article outlines thirteen critical production‑related mistakes—from not externalizing configuration and using inadequate test data to neglecting security, documentation, disaster‑recovery planning, and proper capacity planning—providing actionable guidance for developers and architects to improve system stability and performance.
This article explains the role of the null keyword in Java, its default value for reference types, common pitfalls such as NullPointerException caused by autoboxing, improper primitive assignments, instanceof checks, static method calls on null references, and safe handling techniques to write null‑safe code.
This article introduces a ten‑year journey of a sysadmin turned operations director, outlining why efficient operations are hard, what efficient ops mean, and seven practical strategies—including clear responsibilities, professional processes, and a good service interface—to boost productivity and satisfaction across IT teams.
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 outlines the essential traits of high‑quality interfaces, describes a step‑by‑step process for designing and implementing them, and presents fundamental principles for interface, class, and method design to ensure usability, maintainability, and robustness in software development.
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 article compiles 50 practical PHP performance tips—from using single quotes and static methods to leveraging opcode caching and memcached—detailing how each adjustment can noticeably improve execution speed, memory usage, and overall efficiency of web applications.
This article presents a comprehensive, production‑ready server naming convention that combines memorable word lists, geographic and environment tags, purpose codes, and serial numbers, offering clear DNS A and CNAME records to simplify management, automation, and scalability across large data centers.
When inheriting tangled legacy code, first decide if you’re responsible and willing to invest, then establish comprehensive tests, use version control, make incremental changes, separate cleaning from bug fixing, remove dead code and comments, avoid mutable shared state, and eliminate unnecessary complexity to improve maintainability.
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.
This article presents a comprehensive list of practical UI design principles—ranging from single‑column layouts and clear call‑to‑actions to consistent visual hierarchy and performance optimization—aimed at improving user engagement, reducing friction, and creating intuitive, persuasive interfaces.
