Discover ten practical Python tricks—from skipping unnecessary semicolons and choosing the right editor to leveraging built‑in help, libraries, and disciplined commenting—that can dramatically speed up development and improve code quality for any programmer.
This article summarizes key principles, formatting rules, naming conventions, documentation practices, and coding conventions from the book “The Elements of Java Style,” providing practical guidance for developers who want to write clean, consistent, and maintainable Java code.
This article outlines ten crucial Java programming best‑practice rules—ranging from adding comments and avoiding hard‑coding to proper GUI design and unit testing—to help developers write more readable, maintainable, and high‑performance code.
This article reviews ten frequent Python programming errors—including mutable default arguments, class variable misuse, incorrect exception handling, variable scope pitfalls, list mutation during iteration, closure late binding, circular imports, naming conflicts, Python 2/3 differences, and improper use of del—providing clear explanations and practical solutions to help developers write more reliable code.
A humorous yet insightful look at the myths of massive codebases, featuring developer anecdotes, realistic productivity calculations, and practical advice on prioritizing code quality, solid fundamentals, and modern tooling over sheer line count.
The article shares thirteen practical lessons learned from years of software development, covering starting small, incremental changes, early logging and error handling, thorough testing, creating a safe learning environment, embracing leadership without titles, coding regularly, abstract thinking, and the importance of personal financial safeguards for long‑term career growth.
This guide walks through installing RocketMQ on a CentOS 6.5 VM, launching NameServer and Broker, provides sample Java consumer and producer code, and outlines best‑practice tips for idempotent consumption, batch processing, message filtering, performance tuning, and reliable message delivery.
This article presents eight practical recommendations for Node.js developers, covering dependency locking, lifecycle scripts, modern JavaScript, promises with async/await, code formatting with Prettier, continuous integration testing, security headers via Helmet, and serving over HTTPS.
Learn ten practical Bash scripting techniques—including adding comments, exiting on errors, proper variable quoting, using functions, correct string comparisons, modern command substitution, readonly variables, naming conventions, and debugging—to write more efficient, reliable, and maintainable scripts for Linux automation tasks.
This article explains Redis fundamentals, details the Sentinel mechanism, compares several high‑availability deployment patterns—including Sentinel with DNS or VIP, client‑direct connections, Keepalived/Haproxy, Redis Cluster, Twemproxy, and Codis—provides their advantages and drawbacks, and offers practical best‑practice recommendations for reliable production use.
A cautionary tale of a rookie who erased a production database on day one, followed by real‑world anecdotes, Reddit and Twitter reactions, and practical advice on backups, ticket handling, and strict operational rules to prevent costly data‑loss incidents.
This article explores comprehensive Node.js error handling techniques, covering how to expose errors, differentiate operational and coding errors, choose between throw, callbacks, and EventEmitters, and implement robust error propagation and documentation for resilient backend applications.
This article adapts William Strunk Jr.'s timeless seven writing principles to JavaScript development, showing how functions that do one thing, minimal code, active voice, logical grouping, avoiding spaghetti, feature‑based file organization, and true‑value naming can produce cleaner, more maintainable front‑end code.
HTTP/2 introduced server push to let servers proactively send resources, but it suffers from issues such as cache invalidation after connection closure, difficulty identifying needed pages, lack of authentication reuse, and other pitfalls, so understanding its traps and best practices is essential for effective use.
This article shares 25 practical guidelines for Python testers, covering YAGNI, test relevance, API design, code simplicity, dependency injection, performance testing, and collaborative coding habits to help developers write maintainable, high‑quality software.
This article enumerates 35 common bad programming habits—ranging from code organization and team collaboration to testing and maintenance—and explains why they harm productivity, offering concrete advice on how to recognize and replace each habit with healthier practices.
This guide provides comprehensive PostgreSQL best‑practice recommendations covering naming conventions, column design, constraints, index strategies, NULL handling, development standards, and administration tips to help users quickly adopt consistent and efficient database practices.
This article compiles practical advice from two seasoned engineers—Rebecca Murphey and Philip Walton—covering essential front‑end tools, module usage, testing, build automation, Git strategies, server‑side rendering, Node.js mastery, deep code understanding, browser spec vigilance, code reviews, teamwork, and the value of documenting learning.
The Alibaba Java Development Manual, now in its 1.2.0 version, offers a comprehensive, industry‑tested coding standard that covers layout, examples, rule corrections, and new content, aiming to boost code quality, development efficiency, and future international adoption.
After a year of developing with React Native, this guide shares eleven frequent pitfalls—from misguided project planning and layout handling to Redux store design, component structuring, inline styling, and gesture handling—offering practical advice to help developers build more robust mobile applications.
This article presents comprehensive Java code optimization best practices, covering techniques such as using final modifiers, object reuse, local variables, proper resource handling, loop efficiency, collection sizing, avoiding reflection, and effective map traversal to significantly improve performance and reduce memory consumption.
The article explores how principles of clean code—clear naming, modular structure, and layered logic—can be applied to literary writing, using examples from classic Chinese novels to illustrate how thoughtful variable naming and multi‑threaded organization improve both code readability and narrative clarity.
This article explains why clear, self‑descriptive naming is essential for maintainable code, compares bad and clean naming examples, and offers concrete guidelines on intent‑revealing names, appropriate length, consistent terminology, domain relevance, and contextual clarity.
In this reflective guide, former Mozilla engineer James Long shares personal insights and actionable advice—ranging from finding mentors without idolizing them to tackling big projects and exploring new languages—to help programmers continuously improve their skills and mindset.
This guide presents a comprehensive, step‑by‑step overview of Python coding standards—including indentation, line length, documentation order, spacing, comments, naming conventions, and practical coding tips—helping developers write clear, maintainable, and PEP8‑compliant code.
This article lists ten practical abilities—ranging from version control and writing to debugging and teamwork—that every fresh programmer should acquire to thrive in real‑world software development without formal guidance.
This article examines the role of comments in source code, argues that well‑written, transparent code can often eliminate the need for comments, outlines four levels of code quality, provides concrete refactoring examples, and shares practical clean‑code guidelines such as avoiding magic numbers, reducing parameters, and using contract‑style preconditions.
This comprehensive guide walks beginners through essential HTML and CSS learning resources, practical experiments, and best‑practice techniques—covering semantics, naming conventions, resets, cross‑browser support, preprocessors, grid systems, and portfolio building—to accelerate front‑end development skills.
The article presents five practical concepts—avoiding unnecessary uniqueness, modularizing code, separating concerns, enhancing readability, and choosing clear naming—to help developers write bug‑free, efficient, and easily maintainable code that reduces cognitive load and boosts productivity.
This comprehensive guide explores the fundamentals of API design for front‑end development, covering naming conventions, lexical correctness, parameter ordering, return values, versioning, and extensibility, and provides practical code examples to help developers create intuitive, maintainable, and future‑proof interfaces.
The Dazhong Dianping+ WeChat mini‑program, built by a Meituan‑Dianping engineer using a web‑like hybrid approach, launched on Jan 9 with over two million visits, delivering fast store search and group‑purchase services while adhering to strict limits (1 MB bundle, five pages, no external navigation) through gulp builds, ES6/Promise helpers, manual size optimizations, and Tencent Cloud APIs.
This article presents practical JavaScript clean‑code guidelines—including intention‑revealing naming, single‑purpose functions, pure functions, proper async handling, and linting standards—to help developers write more readable, maintainable, and error‑free code.
This article expands on earlier Node.js best practices by offering concrete, actionable guidelines such as modularizing code, managing require statements, handling errors, using npm shortcuts, respecting versioning, and properly separating development and production dependencies.
This article explains why readable code matters for developers, then offers practical guidelines on naming variables and functions, structuring conditional branches, keeping functions single‑purpose, handling errors, avoiding side‑effects, and organizing class methods to improve maintainability in modern JavaScript projects.
This article outlines the most important Node.js best practices for 2017, including adopting ES2015, using Promises, following coding standards, deploying with Docker, monitoring with Prometheus or Trace, enhancing security with checklists, learning micro‑services, attending conferences, semantic versioning, and using LTS releases.
Effective API design requires shifting from a developer‑centric mindset to the user’s perspective, emphasizing clear documentation, stability, versioning, flexibility, security, and ease of use, while avoiding unnecessary complexity and ensuring consistent, well‑structured interfaces for diverse clients across web, mobile, and IoT platforms.
This article explains how to classify, propagate, and handle both operational and coding errors in Node.js, offering practical guidelines, code examples, and best‑practice recommendations for building robust backend applications.
This article reviews four common approaches—Root Component, Container Component, Redux Async Actions, and Relay—for handling AJAX requests in React, explains when each method is appropriate, and warns against two anti‑patterns, helping developers choose the most suitable strategy for their project's size and architecture.
This article compiles 99 practical principles and habits—from communication and decision‑making to performance, scalability, and team leadership—that every software architect should understand and apply to build high‑quality, maintainable systems and advance their career.
This article shares practical experience on operating Zookeeper clusters, covering core concepts, deployment recommendations, configuration tuning, monitoring, migration strategies, and a list of common issues to avoid for reliable distributed coordination.
This article introduces a Webpack2‑based React‑Redux boilerplate, detailing its architecture, core features, configuration options, development workflow, server‑side rendering support, and best‑practice recommendations, while providing code examples and guidance for both beginners and experienced frontend developers.
This article outlines the essential qualities of a good Pull Request—including meaningful improvements, readability, and maintainability—while also highlighting advanced practices such as priority setting, code review, and automated testing to make PRs more disciplined and artistic.
This article outlines the essential efforts required to excel at API documentation, covering code comprehension, collaboration with engineers, crafting non‑reference guides, understanding readers, mapping dependencies, learning resources, and leveraging tools like Swagger and README.io.
This article explains what design patterns are, why they matter for CSS, and provides practical guidance on structuring, naming, and organizing styles—including recommendations on nesting, selector usage, file ordering, and an overview of popular patterns such as OOCSS, SMACSS, Meta CSS, and BEM—to help front‑end developers write maintainable, scalable code.
This article shares eight hard‑earned recommendations for crafting reliable Bash scripts, covering interpreter selection, debugging flags, static analysis tools, variable expansion, proper scoping, signal trapping, thoughtful design, and recognizing when to switch to more suitable languages.
This discussion post examines whether code should be commented, citing the book *Refactoring* and emphasizing that needing comments often signals the need for refactoring, while good variable names can serve as implicit documentation, and stresses the importance of clear interface comments.
This article identifies why most code remains low‑quality despite many guidelines and presents four practical principles—single abstraction level, minimized indentation, clear expressions, and effective use of helper classes—that dramatically improve a team's coding standards.
This guide summarizes key resources on functional programming, performance optimization, testing strategies, and coding standards, showing how mastering these four areas can transform any Python programmer into a highly effective and sought‑after developer.
This article outlines essential MongoDB document best‑practice guidelines, including key naming restrictions, collection organization, avoiding custom _id values, pitfalls of array fields, compression of large fields, using MD5 hashes for long strings, case‑sensitivity handling, and index size limits, illustrated with real‑world cases.
Discover how the Node.js Playbook offers a practical roadmap, best‑practice tips, and essential tools for developers seeking a clear, actionable guide to mastering Node.js, while also outlining its limitations and inviting community contributions.
This article outlines five practical commandments that help data scientists and data engineers collaborate more effectively, covering data awareness, tool familiarity, technical limits, mutual respect, and shared responsibility to ensure smooth project delivery.
The article shares practical insights and a comprehensive checklist for conducting code reviews, emphasizing formatting, readability, corner‑case coverage, error handling, testing, and architectural considerations to improve code quality and foster team growth.
This article explores the challenges of CSS class naming, traces its evolution from chaotic practices through atomic and modular approaches to the widely adopted BEM methodology, and provides practical rules, keyword lists, and code examples for creating clear, maintainable, and conflict‑free class structures.
This article outlines the essential mindset, problem‑solving approach, solid PHP fundamentals, and comprehensive internet application and project‑management knowledge required for developers aspiring to senior PHP engineer roles.
This article shares practical DBA advice—pre‑operation preparation, thorough fault analysis, effective communication, mandatory backups, and post‑incident reviews—to help database administrators maintain stability and avoid costly mistakes during online operations.
This guide presents twenty‑five practical PHP security measures, covering server environment setup, configuration directives, module management, file permissions, logging, SELinux, firewall rules, and tools such as Suhosin and ModSecurity to harden PHP applications on Linux/Apache systems.
This article outlines ten practical guidelines for operations engineers—ranging from mandatory rollback testing and cautious handling of destructive commands to robust backup verification, vigilant monitoring, and disciplined handover procedures—to dramatically reduce system outages and improve overall reliability.
This article shares eBay’s seven core scalability best practices—including functional partitioning, horizontal sharding, avoiding distributed transactions, asynchronous decoupling, stream processing, virtualization, and smart caching—to help architects design highly available, cost‑effective systems that can handle billions of daily requests.
Discover 26 practical agile development principles—from building test cases before code to avoiding premature optimization—that guide teams to deliver high-quality software efficiently, emphasizing incremental work, continuous testing, thoughtful design, and disciplined code management.
This article examines typical mistakes in Nginx‑PHP setups—such as misplaced index directives, misuse of the if statement, and fastcgi configuration quirks—and provides a streamlined, secure configuration example with explanations.
This article examines typical mistakes in Nginx‑PHP configurations—such as misplaced index directives, misuse of the if statement, and fastcgi parameter issues—and presents a cleaner, more reliable configuration using inheritance, try_files, and the appropriate fastcgi.conf file.
This article outlines practical PHP coding standards—including line breaks, spacing, naming conventions, PSR guidelines, and useful habits like method‑chaining layout and array formatting—to help developers write cleaner, more maintainable backend code.
This article provides comprehensive front‑end development guidelines covering the proper HTML5 DOCTYPE, semantic markup, alt text, table usage, microformats, jQuery UI, consistent JavaScript style, performance optimizations, unique ID generation, feature detection, and readable code conventions.
Closing database connections promptly is essential for performance and availability, and this guide explains practical rules, connection‑pool benefits, safe coding patterns, exception handling, and how to diagnose lingering connections using MySQL's SHOW PROCESSLIST command.
This article lists thirteen frequent production‑level problems—from missing configuration externalization and inadequate testing data to insufficient security, documentation, monitoring, and rollback planning—providing a checklist for developers and architects to prevent costly issues.
The article explains why and how to adopt open‑source projects, covering their benefits, common pitfalls, and practical guidance on selecting, using, and extending them safely through careful evaluation, testing, operational readiness, and thoughtful customization.
The article reveals four common programming pitfalls—premature or late optimization, over‑complex abstractions, misuse of tools, and misguided cross‑platform efforts—and provides practical patches to keep developers from sinking into endless deadlines and frustration.
This article presents a comprehensive list of 17 essential PHP best‑practice tips—ranging from using absolute paths and custom loaders to proper output buffering, character encoding, session handling, and file permission management—to help developers write cleaner, more maintainable, and secure backend code.
This article shares practical techniques for generating passwords that are easy to remember but difficult for others to guess, including using initials of poems, personal info combined with app names and random numbers, and custom keyboard patterns, while emphasizing the importance of a consistent rule.
The author, a veteran web developer, argues that while front‑end frameworks like Angular, Backbone, and Knockout offer shortcuts, they violate core software principles, increase maintenance burden, and often hinder true architectural understanding, urging developers to favor solid design patterns instead of heavyweight frameworks.
This article explains practical techniques for writing high‑quality functions, covering consistent naming conventions, descriptive function names, optimal parameter handling, clean function bodies, reduced nesting, and other best‑practice tips to improve readability and testability.
This article explores the DRY principle in software development, explains why many open‑source projects violate it, and provides practical guidance on selecting, using, and customizing open‑source solutions through real‑world case studies, focusing on business fit, maturity, operational capability, and safe integration.
This article shares eleven practical rules for software developers, ranging from treating technology as a tool rather than a solution, writing clear code, avoiding unnecessary code, limiting comments, planning before coding, testing thoroughly, continuous learning, enjoying coding, acknowledging unknowns, adapting best practices, and striving for simplicity.
This article explains why consistent PHP coding standards—covering line breaks, spacing, naming, and habits like method chaining and array formatting—are essential for readable, maintainable code, and offers practical examples and tools to enforce them across a development team.
The article provides comprehensive guidelines for writing high‑quality functions, covering naming conventions, parameter design, and body implementation techniques such as reducing nesting, avoiding mutable inputs, and using clear verbs to improve readability, maintainability, and testability across programming languages.
Through a collection of humorous and often pointless code comment examples, the article examines how developers use annotations—ranging from cryptic references to overly detailed narratives—to convey (or obscure) intent, highlighting best practices and pitfalls in writing effective code comments.
The author, a veteran web developer, argues that relying on frontend frameworks hinders true understanding of software principles, advocating for modular design, design patterns, and architecture fundamentals over framework‑driven development.
This article reviews a decade of cloud security experience and outlines the key challenges of operations security in public cloud environments, offering concrete solutions such as VPC isolation, encrypted VPNs, RAM policies, Linux key‑based login, Windows RDP port changes, privileged‑account management, and ActionTrail auditing.
The author recounts how strict coding standards at Google transformed his view, showing that uniform indentation, naming, and comment styles dramatically improve code readability, speed up understanding across teams, and outweigh common objections about creativity, flexibility, or perceived waste of time.
This article presents ten expert‑backed PHP best practices—from choosing the right use cases and leveraging multi‑table storage for scalability, to security, caching, IDE usage, filtering functions, framework decisions, batch processing, and enabling error reporting—offering actionable guidance for building robust, high‑performance web applications.
This article presents Uber engineering leader Raffi Krikorian’s twelve practical rules for planning, executing, and validating architecture refactoring, covering purpose definition, incremental delivery, data handling, technical debt, technology choices, pressure management, business alignment, non‑technical factors, code quality, and team readiness.
This article examines recent high‑profile internet outages caused by human error, explores why operations teams are especially prone to mistakes despite automation and standards, and offers practical strategies—such as hiring the right people, fostering safety awareness, and turning professionalism into habit—to reduce future incidents.
This comprehensive guide explains Python coding style best practices, covering PEP 8 extensions, flexible line length, naming conventions, docstring standards, functional versus object‑oriented design, testing, standard library usage, third‑party tools, and project structure to produce readable, maintainable code.
This article explains how to objectively assess code quality by defining good code, discussing readability, documentation, exception handling, concurrency, performance, logging, maintainability, modularization and providing recommended reading, helping developers and reviewers establish consistent evaluation standards.
This article presents a detailed guide to modern Java development, covering coding style, immutable data structures, builder patterns, dependency injection, null handling, formatting, Javadoc, streams, publishing strategies, Maven configuration, CI tools, repository management, configuration automation, essential development tools, and a curated list of widely used Java libraries.
This article highlights five common programming mistakes—copying code without understanding, reinventing the wheel, over‑relying on Google, ignoring warnings, and applying quick fixes instead of permanent solutions—explaining why they harm code quality and offering practical advice to help developers write cleaner, more maintainable software.
This article examines why developers produce low‑quality, hard‑to‑maintain code, describing common anti‑patterns such as unclear intent, unreadable logic, poor organization, and missing abstractions, and discusses the difficulties of refactoring such code, while offering insights into recognizing and improving code quality.
The article explains how to write robust, error‑free code by always using two‑branch if statements, handling return values and exceptions correctly, avoiding null‑pointer pitfalls, and steering clear of over‑engineering through practical examples and clear best‑practice guidelines.
The article presents a comprehensive philosophy on software development, emphasizing the importance of repeatedly refining code, structuring it elegantly, modularizing with clear functions, avoiding unnecessary comments, and adopting simple, intuitive practices to improve readability and maintainability across any programming language.
This article outlines ten practical habits—from mastering fundamentals and labeling code to continuous learning and avoiding shortcuts—that can help any software developer grow into an exceptional programmer who writes clean, maintainable, and impactful code.
This article provides a comprehensive walkthrough of Oracle's XTTS technology, covering its evolution, traditional and incremental‑backup workflows, version constraints, detailed configuration steps, real‑world migration timing, common pitfalls, remediation tactics, and a concise Q&A for practitioners.
This article compiles Russell Smith’s comprehensive MongoDB best‑practice guide, covering architecture choices, file limits, write safety, schema design, replication, sharding, security, and performance tuning to help engineers avoid common pitfalls and optimize production deployments.
This article shares practical programming philosophy and concrete techniques—such as iterative code refinement, modular design, readable naming, avoiding unnecessary language features, and clear control flow—to help developers consistently produce elegant, maintainable, and bug‑free code.
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.
