BestHub
Sign in
Tagged articles
1752 articles
Page 17 of 18
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Feb 4, 2017 · Fundamentals

What Are Software Architecture Styles and Why They Matter

This article explains software architecture styles as high‑level design principles that guide system families, outlines common styles, their benefits and drawbacks, discusses open design questions, and provides detailed examples such as client‑server, layered, pipe‑filter, event‑driven, repository, C2, three‑tier, JB/HMB, and REST architectures.

Design PatternsSoftware ArchitectureSystem Design
0 likes · 47 min read
What Are Software Architecture Styles and Why They Matter
ITPUB
ITPUB
Jan 20, 2017 · Fundamentals

How to Keep Your Programming Skills Fresh and Avoid Becoming Outdated

The article offers practical strategies for programmers to stay current, including learning new languages, using knowledge in novel ways, tackling client challenges, occasionally abandoning frameworks, seeking code reviews, and continuously coding to prevent skill decay.

Skill Developmentcareer advicecontinuous learning
0 likes · 5 min read
How to Keep Your Programming Skills Fresh and Avoid Becoming Outdated
Huawei Cloud Developer Alliance
Huawei Cloud Developer Alliance
Jan 9, 2017 · Fundamentals

Why Great Code Needs Great Diagrams: Unlocking Visual Design in Software Development

The article reflects on the shift from pure coding to embracing requirement analysis, testing, and especially diagramming, explaining how visual representations externalize information, foster exploration, support global thinking, and make abstract concepts intuitive, ultimately improving software quality and collaboration.

architecture diagramscoding practicessoftware design
0 likes · 6 min read
Why Great Code Needs Great Diagrams: Unlocking Visual Design in Software Development
Huawei Cloud Developer Alliance
Huawei Cloud Developer Alliance
Jan 5, 2017 · Fundamentals

What Makes an Ideal Programmer? 6 Practical Traits to Master

This reflective guide explores the journey from novice to seasoned developer, classifies programmers into three types, and outlines six essential habits—focus, analytical thinking, constructive refusal, future investment, tool mastery, and time management—that together define an ideal programmer.

career developmentcontinuous learningproductivity
0 likes · 11 min read
What Makes an Ideal Programmer? 6 Practical Traits to Master
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Dec 30, 2016 · R&D Management

How Alibaba’s Detail 2.0 Platform Revolutionizes Modular Development and Front‑Back Separation

This article explains how Alibaba’s Detail 2.0 platform redesigns product‑detail services through modular architecture, front‑back separation, standardized frameworks, automated testing, and flexible deployment to boost collaboration efficiency, stability, and extensibility across diverse business scenarios.

Modular Designcontinuous integrationfrontend backend separation
0 likes · 17 min read
How Alibaba’s Detail 2.0 Platform Revolutionizes Modular Development and Front‑Back Separation
High Availability Architecture
High Availability Architecture
Dec 11, 2016 · Artificial Intelligence

Why Machine Learning Is Hard: Debugging Challenges and Exponential Difficulty

The article explains that while machine learning has advanced with abundant courses, textbooks, and frameworks, engineers still face hard debugging problems due to algorithmic, implementation, data, and model dimensions, leading to exponential difficulty and long feedback loops that demand intuition and systematic testing.

Artificial IntelligenceDebuggingMachine Learning
0 likes · 8 min read
Why Machine Learning Is Hard: Debugging Challenges and Exponential Difficulty
Java Captain
Java Captain
Dec 8, 2016 · Backend Development

Essential Skills and Interview Preparation Guide for Java Software Engineers

This comprehensive guide outlines the core technical competencies, project experience details, management practices, system architecture components, third‑party tools, common interview questions, and effective interview strategies that every aspiring Java backend developer should master before a job interview.

Backend DevelopmentInterview preparationsoftware engineering
0 likes · 11 min read
Essential Skills and Interview Preparation Guide for Java Software Engineers
High Availability Architecture
High Availability Architecture
Dec 5, 2016 · Fundamentals

Improving Test Infrastructure for Legacy System Refactoring: Insights from Google Test Engineers

The article explains how Google test engineers tackle the challenges of maintaining and upgrading legacy systems by redesigning test infrastructure, reducing reliance on fragile end‑to‑end tests, and adopting lightweight, mock‑driven test cases that dramatically speed up verification while preserving defect detection quality.

integration testinglegacy systemsmock services
0 likes · 8 min read
Improving Test Infrastructure for Legacy System Refactoring: Insights from Google Test Engineers
Java Captain
Java Captain
Nov 24, 2016 · Backend Development

Essential Skills and Interview Preparation Guide for Java Software Engineers

This comprehensive guide outlines the core Java programming competencies, web development frameworks, project experience, management tools, system architecture components, interview questions, and personal evaluation tips that aspiring Java engineers should master before a job interview.

Backend DevelopmentHibernateInterview preparation
0 likes · 11 min read
Essential Skills and Interview Preparation Guide for Java Software Engineers
Architects' Tech Alliance
Architects' Tech Alliance
Nov 3, 2016 · Industry Insights

Scaling Billion‑Level Ads: Architecture Lessons from Sogou’s Senior Engineer

In this interview, Sogou architect Liu Jian shares how his team built a highly available, scalable commercial advertising platform, discusses the evolution of its infrastructure, offers practical advice for engineers aspiring to become architects, and reflects on emerging technologies and time‑management strategies.

Big DataDistributed SystemsPlatform Engineering
0 likes · 10 min read
Scaling Billion‑Level Ads: Architecture Lessons from Sogou’s Senior Engineer
Huawei Cloud Developer Alliance
Huawei Cloud Developer Alliance
Oct 21, 2016 · Backend Development

From C to Java: Essential Steps for a Smooth Transition

This guide walks C programmers through transitioning to Java, covering why Java is approachable, essential tools, coding standards, exception handling, core SDK libraries, object‑oriented fundamentals, and advanced topics like Effective Java, SOLID principles, design patterns, and functional programming with Java 8.

C ProgrammingJavaJava 8
0 likes · 7 min read
From C to Java: Essential Steps for a Smooth Transition
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Oct 18, 2016 · Fundamentals

Master UML: Understanding the 9 Essential Diagram Types for System Design

This article explains UML as a modeling language, detailing its semantics and notation, and introduces the nine core diagram types—use case, class, object, static, behavior, interaction, implementation, component, and deployment—highlighting their purposes, differences, and how they support static and dynamic system modeling.

Software ModelingSystem DesignUML
0 likes · 10 min read
Master UML: Understanding the 9 Essential Diagram Types for System Design
360 Quality & Efficiency
360 Quality & Efficiency
Sep 20, 2016 · Fundamentals

Should You Add Comments to Your Code? – Insights from Refactoring

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.

Best Practicescode commentscoding standards
0 likes · 2 min read
Should You Add Comments to Your Code? – Insights from Refactoring
Alibaba Cloud Developer
Alibaba Cloud Developer
Sep 14, 2016 · Frontend Development

Mastering Front-End Growth: Building Skills and Knowledge Systematically

This article outlines a comprehensive approach for front‑end developers to achieve career growth by balancing ability and knowledge, offering practical steps to build a personal knowledge system, improve programming, architecture, and engineering skills, and adopt systematic training with classic textbooks.

Front-endcareer developmentknowledge management
0 likes · 12 min read
Mastering Front-End Growth: Building Skills and Knowledge Systematically
Architecture Digest
Architecture Digest
Sep 2, 2016 · Fundamentals

Programming Philosophy: Writing Elegant, Modular, Readable, and Robust Code

The article presents a comprehensive programming philosophy that emphasizes repeatedly refining code, writing elegant, modular, readable, and simple programs, handling errors and null pointers robustly, and avoiding over‑engineering, offering practical guidelines applicable to any software development language.

Error HandlingNull Safetyrefactoring
0 likes · 41 min read
Programming Philosophy: Writing Elegant, Modular, Readable, and Robust Code
21CTO
21CTO
Aug 28, 2016 · R&D Management

From Coder to CTO: How Tech Roles Evolve and What They Actually Do

This article outlines the responsibilities and career progression of technical roles—from entry‑level programmers to senior engineers, architects, technical managers, directors, and CTOs—highlighting how each level adds scope, leadership, and strategic impact within an organization.

CTORole Hierarchycareer progression
0 likes · 9 min read
From Coder to CTO: How Tech Roles Evolve and What They Actually Do
DevOps
DevOps
Aug 14, 2016 · Fundamentals

Effective Code Review Practices and Checklist

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.

Best PracticesCode Reviewchecklist
0 likes · 8 min read
Effective Code Review Practices and Checklist
Qunar Tech Salon
Qunar Tech Salon
Jul 14, 2016 · Operations

Google’s Monolithic Repository: The Piper System and Its Benefits and Challenges

Google’s engineers explain in an ACM Communications paper how their custom monolithic repository, managed by the Piper version‑control system built on Spanner, supports billions of files and lines of code, enabling trunk‑based development, rapid code visibility, and large‑scale refactoring, while also requiring substantial tooling investment and operational complexity.

Google PiperVersion Controllarge-scale codebase
0 likes · 12 min read
Google’s Monolithic Repository: The Piper System and Its Benefits and Challenges
Architecture Digest
Architecture Digest
Jul 8, 2016 · R&D Management

Technical Knowledge Summary from 8 Years of IT Experience

After nearly a decade of work in embedded, web, mobile, consulting, and integration projects, the author outlines four major knowledge areas—engineering methods, system integration, project management, and development—detailing essential practices, design principles, and technology stacks such as C, Android, cloud services, and big data.

Embedded DevelopmentProject ManagementSystem Integration
0 likes · 9 min read
Technical Knowledge Summary from 8 Years of IT Experience
21CTO
21CTO
Jun 29, 2016 · Fundamentals

Why Engineers Should Embrace Broad Skills Over Narrow Specialization

The article reflects on the diverse career paths for engineering graduates, warns against over‑specialization, emphasizes continuous learning, and highlights how engineers can leverage analytical strengths for both technical and organizational growth in today’s fast‑changing tech landscape.

Growth Hackingcareer developmentengineer mindset
0 likes · 8 min read
Why Engineers Should Embrace Broad Skills Over Narrow Specialization
Architecture Digest
Architecture Digest
Jun 29, 2016 · Fundamentals

Recommended Books for Software Architecture and Design Patterns

This article presents a curated list of essential books covering software architecture fundamentals, design patterns, domain‑specific frameworks, RUP/UML methodologies, and additional leisure reads, along with practical reading strategies for developers and architects.

Book RecommendationsUMLsoftware engineering
0 likes · 8 min read
Recommended Books for Software Architecture and Design Patterns
Qunar Tech Salon
Qunar Tech Salon
Jun 22, 2016 · Fundamentals

Three Life Lessons Learned from 17 Years of Programming

After seventeen years of coding, the author shares three enduring lessons—balancing trade‑offs, valuing clarity over mere brevity, and treating technical debt as a manageable asset—illustrated with real‑world examples, ORM discussions, and code snippets that apply both to software development and everyday decisions.

Technical debtcode claritydecision making
0 likes · 8 min read
Three Life Lessons Learned from 17 Years of Programming
Efficient Ops
Efficient Ops
Jun 18, 2016 · Fundamentals

How to Build a T‑Shaped Skill Set: Master Breadth and Depth as a Developer

The article explains how developers can overcome learning uncertainty by combining horizontal (breadth) and vertical (depth) learning strategies to create a T‑shaped skill profile, offering practical steps for framework selection, deep mastery, and continuous growth.

Skill DevelopmentT-shapedbreadth learning
0 likes · 6 min read
How to Build a T‑Shaped Skill Set: Master Breadth and Depth as a Developer
21CTO
21CTO
Jun 18, 2016 · Fundamentals

How to Become a Full‑Stack Engineer: Lessons from 15 Years of Coding

This article shares a veteran developer’s journey from early web pages to modern full‑stack engineering, offering practical advice on mastering front‑end, back‑end, and mobile technologies, the importance of broad skills, and a realistic roadmap to becoming a versatile software professional.

FrontendWeb Developmentbackend
0 likes · 7 min read
How to Become a Full‑Stack Engineer: Lessons from 15 Years of Coding
21CTO
21CTO
Jun 11, 2016 · Fundamentals

Why Technical Debt Accumulates and How to Tackle It Effectively

The article shares a veteran IT professional’s insights on how technical debt forms, the risks it brings, various repayment strategies, and practical ways to prevent debt crises, emphasizing continuous management and disciplined engineering practices.

Technical debtrefactoringrisk management
0 likes · 12 min read
Why Technical Debt Accumulates and How to Tackle It Effectively
21CTO
21CTO
Jun 9, 2016 · Fundamentals

How Feross Aboukhadijeh Built a Winning Engineer Brand and What You Can Learn

This article explores Feross Aboukhadijeh's approach to personal branding, crafting a standout Silicon Valley resume, leveraging GitHub, and learning programming through extensive project building, offering actionable advice for engineers seeking career growth and visibility.

GitHubcareer developmentlearning programming
0 likes · 13 min read
How Feross Aboukhadijeh Built a Winning Engineer Brand and What You Can Learn
21CTO
21CTO
Jun 5, 2016 · R&D Management

How to Build Effective Tech Team Structures from Startup to Enterprise

This article explains how internet companies can design and evolve technical team hierarchies—from flat, three‑level startups to large, multi‑team enterprises—by aligning roles, responsibilities, and communication flows to product scale and business goals.

R&D ManagementTeam Organizationsoftware engineering
0 likes · 7 min read
How to Build Effective Tech Team Structures from Startup to Enterprise
Qunar Tech Salon
Qunar Tech Salon
May 27, 2016 · Operations

Segmented Implementation Strategy for System Architecture Refactoring

To effectively refactor a legacy system, the article proposes a staged implementation approach that prioritizes issues by severity, categorizes problems, and tackles easier tasks first, thereby concentrating limited resources, reducing risk, and delivering visible improvements in usability, performance, and scalability across successive phases.

Software Architecturesoftware engineeringstaged implementation
0 likes · 8 min read
Segmented Implementation Strategy for System Architecture Refactoring
Qunar Tech Salon
Qunar Tech Salon
May 25, 2016 · R&D Management

Effective Communication Strategies for Architecture Refactoring Projects

The article explains how to successfully launch and drive large‑scale architecture refactoring by translating technical jargon into plain language, using data‑driven arguments, empathizing with stakeholders, and employing structured escalation and win‑win negotiation tactics to align cross‑functional teams.

R&D Managementarchitecturecommunication
0 likes · 9 min read
Effective Communication Strategies for Architecture Refactoring Projects
Architecture Digest
Architecture Digest
May 20, 2016 · Fundamentals

Key Recommendations for System Architecture Design

The article shares a series of practical recommendations for improving system architecture design, emphasizing the need to avoid premature API planning, make decisive technology choices, eliminate triangular call relationships, clearly define program modules, adopt a star‑shaped hub architecture, separate business logic, ensure transaction safety, and isolate scheduling from business via databases.

Modular DesignSystem ArchitectureTechnology Selection
0 likes · 5 min read
Key Recommendations for System Architecture Design
21CTO
21CTO
May 15, 2016 · Fundamentals

The Programmer’s Paradox: Why Top Developers Spend Most Time on Disliked Tasks

The article explains the paradox that good programmers spend the majority of their time on tasks, technologies, and tools they dislike because these “bad” technologies consume disproportionate effort, while automation‑friendly work is quickly delegated, leading to chronic frustration despite their expertise.

Technical debtautomationdeveloper productivity
0 likes · 6 min read
The Programmer’s Paradox: Why Top Developers Spend Most Time on Disliked Tasks
Architecture Digest
Architecture Digest
May 15, 2016 · R&D Management

From Junior to Architect: Understanding Software Development Career Stages

The article reflects on the three career stages of software developers—junior, intermediate, and senior/architect—highlighting their evolving technical choices, team responsibilities, and the importance of experience, broad knowledge, and management skills for becoming an effective software architect.

R&Dcareer developmentsoftware engineering
0 likes · 10 min read
From Junior to Architect: Understanding Software Development Career Stages
21CTO
21CTO
May 12, 2016 · R&D Management

How to Interview Software Engineers Effectively: Insider Tips & Common Pitfalls

This article shares practical insights on interviewing software engineers, exposing hiring biases, recommending interview structures, small‑talk techniques, broad and specific technical questions, project‑based assessments, and how to create a fair, inclusive process that reveals true talent.

R&D Managementcareer advicehiring
0 likes · 9 min read
How to Interview Software Engineers Effectively: Insider Tips & Common Pitfalls
21CTO
21CTO
May 11, 2016 · Fundamentals

5 Core Skills Every High‑Performance Software Engineer Must Master

This article outlines five essential abilities—embracing new languages, mastering debugging, creating time‑saving tools, speeding up repetitive tasks, and adopting systemic thinking—that high‑performing software engineers need to boost productivity and deliver impactful, well‑engineered solutions.

Debuggingproductivitysoftware engineering
0 likes · 5 min read
5 Core Skills Every High‑Performance Software Engineer Must Master
DevOps
DevOps
May 11, 2016 · R&D Management

How a Junior Developer Became an Architect: A Career Journey

The article narrates the story of a fresh graduate named Xiao Wang who, through curiosity, proactive learning, helping others, and continuous technical improvement, rises from filling simple framework templates to leading a team and being appointed as a product architect, illustrating the path to senior technical roles.

LeadershipSoftware Architecturecareer development
0 likes · 6 min read
How a Junior Developer Became an Architect: A Career Journey
21CTO
21CTO
May 3, 2016 · R&D Management

From Code to CTO: How Passion and Clear Goals Shape a Developer’s Journey

A seasoned developer shares his 15‑year journey from a small‑town programmer to architect and aspiring CTO, emphasizing the power of interest‑driven learning, clear objectives, continuous skill expansion, and leadership principles for turning technical expertise into influential management roles.

CTOLeadershipMotivation
0 likes · 9 min read
From Code to CTO: How Passion and Clear Goals Shape a Developer’s Journey
21CTO
21CTO
Apr 30, 2016 · R&D Management

From Google Engineer to First‑Time CTO: Leadership, Communication, and Tech Choices

Lan Langworth, a former Google engineer and co‑founder of Artillery, shares his candid journey from leaving Google to becoming a CTO, offering practical insights on direction, communication pitfalls, building a developer‑focused culture, choosing technologies, and trusting intuition in a fast‑moving startup environment.

CTOLeadershipStartup
0 likes · 13 min read
From Google Engineer to First‑Time CTO: Leadership, Communication, and Tech Choices
21CTO
21CTO
Apr 29, 2016 · R&D Management

How to Evolve from Reliable Engineer to Effective Leader: Key Practices

The article shares practical insights for engineers transitioning to management, emphasizing the shift from doing to delegating, prioritizing important over urgent tasks, establishing clear rules, fostering team communication, and mastering strategic thinking to drive both personal and team growth.

LeadershipManagementTeam Collaboration
0 likes · 5 min read
How to Evolve from Reliable Engineer to Effective Leader: Key Practices
Art of Distributed System Architecture Design
Art of Distributed System Architecture Design
Apr 22, 2016 · Industry Insights

Why Do Architects Still Write Code? Lessons on Learning, Meetings, and System Longevity

The article shares a senior engineer’s reflections on systematic learning, the role of architects in coding, the pitfalls of endless meetings, how to keep systems alive, and practical questioning techniques that boost problem‑solving efficiency for software professionals.

System Architecturecareer developmentcommunication
0 likes · 15 min read
Why Do Architects Still Write Code? Lessons on Learning, Meetings, and System Longevity
Java Captain
Java Captain
Apr 16, 2016 · Backend Development

Essential Skills and Interview Preparation Guide for Java Developers

This comprehensive guide outlines the core Java programming skills, project experience, development processes, tools, interview questions, and personal evaluation tips that candidates should master to succeed in Java developer interviews and advance their careers.

Backend DevelopmentInterview preparationsoftware engineering
0 likes · 12 min read
Essential Skills and Interview Preparation Guide for Java Developers
21CTO
21CTO
Apr 14, 2016 · R&D Management

Why 35 Years of Coding Still Leaves Me Regretting Not Pursuing Management

A veteran programmer reflects on decades of coding, realizing that without authority, technical skill alone cannot change failing products or projects, and regrets not taking management roles that could have offered greater impact, financial reward, and career fulfillment.

Leadershipcareer developmentprogrammer experience
0 likes · 10 min read
Why 35 Years of Coding Still Leaves Me Regretting Not Pursuing Management
Qunar Tech Salon
Qunar Tech Salon
Apr 13, 2016 · Operations

13 Common Production Pitfalls Developers and Architects Should Avoid

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.

Best Practicesproductionsoftware engineering
0 likes · 10 min read
13 Common Production Pitfalls Developers and Architects Should Avoid
21CTO
21CTO
Apr 13, 2016 · Backend Development

How to Choose, Use, and Extend Open‑Source Projects Without Reinventing the Wheel

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.

Best PracticesOpen Sourceproject selection
0 likes · 14 min read
How to Choose, Use, and Extend Open‑Source Projects Without Reinventing the Wheel
Qunar Tech Salon
Qunar Tech Salon
Apr 7, 2016 · Fundamentals

9 Bad Programming Habits We Secretly Love

The article humorously explores nine commonly discouraged programming habits—such as using goto, avoiding documentation, cramming code onto one line, omitting type declarations, and redefining operators—explaining why developers sometimes break rules and how these practices can affect code readability, maintainability, and performance.

bad practicescode qualitycoding style
0 likes · 14 min read
9 Bad Programming Habits We Secretly Love
21CTO
21CTO
Apr 1, 2016 · Fundamentals

Master Design Patterns: Principles and All 3 Types Explained

This article provides a comprehensive overview of software design principles and the three major categories of design patterns—creational, structural, and behavioral—detailing each principle, pattern, its participants, and practical implications for building flexible, maintainable systems.

Behavioral PatternsCreational PatternsDesign Patterns
0 likes · 34 min read
Master Design Patterns: Principles and All 3 Types Explained
21CTO
21CTO
Mar 31, 2016 · Fundamentals

8 Proven Habits to Transform Into a Better Programmer

This article outlines eight practical, actionable guidelines—ranging from acknowledging what you don’t know to collaborating one‑on‑one with peers—that can dramatically boost your programming skills and help you become a more effective, self‑driven developer.

career developmentcoding habitsprogramming
0 likes · 9 min read
8 Proven Habits to Transform Into a Better Programmer
21CTO
21CTO
Mar 26, 2016 · R&D Management

Why Uninterrupted Deep Work Beats Frequent Meetings for Developers

The article explains how programmers need long, uninterrupted periods of deep work (the "quiet" mode) to solve complex problems, while managers thrive in a meeting‑driven "worldly" mode, and argues that balancing these two states and protecting developers from mid‑day interruptions can dramatically improve productivity.

R&Ddeep workmeeting management
0 likes · 6 min read
Why Uninterrupted Deep Work Beats Frequent Meetings for Developers
Qunar Tech Salon
Qunar Tech Salon
Mar 18, 2016 · Fundamentals

Why Visual Programming Tools Fail in Enterprise Data Analysis

The article examines the shortcomings of visual programming tools for data scientists, highlighting issues such as poor version control, limited IDE flexibility, lack of open‑source integration, and reduced modularity, and argues that code‑first approaches remain more effective in enterprise environments.

Data AnalysisVisual Programmingcode vs tools
0 likes · 11 min read
Why Visual Programming Tools Fail in Enterprise Data Analysis
Qunar Tech Salon
Qunar Tech Salon
Mar 17, 2016 · Fundamentals

The Four Stages of Programming Competence: A Psychological Perspective

The article applies Freud's conscious‑unconscious model to programming, describing four (and a possible fifth) stages of competence illustrated with real‑world examples, and argues that this psychological framework effectively explains skill development for developers.

PsychologySkill Developmentcompetence stages
0 likes · 7 min read
The Four Stages of Programming Competence: A Psychological Perspective
21CTO
21CTO
Mar 7, 2016 · Fundamentals

Are You a Bad Programmer? Spot the Traits That Hold Your Code Back

This article examines the two main types of poor developers—‘cowboy’ programmers who rush code without maintainability and mediocre coders lacking competence—explores their harmful habits such as spaghetti code, endless bugs, and arrogance, and outlines how good developers differ through humility, responsibility, and continuous learning.

bad programmingcode qualitydeveloper habits
0 likes · 14 min read
Are You a Bad Programmer? Spot the Traits That Hold Your Code Back
21CTO
21CTO
Mar 5, 2016 · Backend Development

How to Choose, Use, and Extend Open‑Source Projects Without Reinventing the Wheel

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.

Best PracticesOpen SourceOperations
0 likes · 12 min read
How to Choose, Use, and Extend Open‑Source Projects Without Reinventing the Wheel
21CTO
21CTO
Mar 4, 2016 · Fundamentals

11 Essential Rules Every Programmer Should Live By

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.

Best Practicescoding rulesproductivity
0 likes · 9 min read
11 Essential Rules Every Programmer Should Live By
dbaplus Community
dbaplus Community
Mar 3, 2016 · Operations

Why Every Developer Must Master Core Ops Skills

The article explains why developers need to understand operations—covering resource usage, fault handling, platform basics, and essential ops tools—so they can write maintainable code, avoid common pitfalls, and collaborate effectively with ops teams for reliable, high‑performance services.

MonitoringOperationscoding standards
0 likes · 14 min read
Why Every Developer Must Master Core Ops Skills
21CTO
21CTO
Mar 1, 2016 · Fundamentals

Why Bad Code Survives and How Refactoring Can Save Your Projects

The article examines why developers often produce low‑quality, hard‑to‑maintain code, outlines common bad‑code patterns, discusses the limited benefits and high costs of refactoring, and offers practical advice for writing better, more maintainable software.

bad code patternscode qualitymaintainability
0 likes · 12 min read
Why Bad Code Survives and How Refactoring Can Save Your Projects
Qunar Tech Salon
Qunar Tech Salon
Mar 1, 2016 · Fundamentals

How to Write High‑Quality Functions: Naming, Parameters, and Implementation Practices

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.

Best Practicescode qualityfunction design
0 likes · 16 min read
How to Write High‑Quality Functions: Naming, Parameters, and Implementation Practices
21CTO
21CTO
Feb 27, 2016 · Fundamentals

How Margaret Hamilton’s Code Sent Humans to the Moon and Shaped Modern Software

Margaret Hamilton, the pioneering software engineer behind the Apollo Guidance Computer, overcame gender bias, invented key software engineering practices, and laid the groundwork for modern computing, illustrating how early system programming turned a daring space mission into a historic triumph.

Apollo programMargaret HamiltonWomen in Tech
0 likes · 12 min read
How Margaret Hamilton’s Code Sent Humans to the Moon and Shaped Modern Software
21CTO
21CTO
Feb 23, 2016 · Fundamentals

Why Writing Less Code Makes You a Better Developer

The article argues that while writing code is essential, the true goal of developers is to minimize code through thoughtful design, using tools that reduce errors, and continuously refactoring to keep code clear, maintainable, and a harmless by‑product of solving problems.

code minimizationcode qualitydevelopment practices
0 likes · 4 min read
Why Writing Less Code Makes You a Better Developer
21CTO
21CTO
Feb 23, 2016 · Backend Development

From Personal Homepage to Billion‑Page Site: Lessons in Scalable Web Architecture

This article shares a 14‑year journey of building and evolving website architectures, from a simple personal homepage to billion‑page platforms, highlighting essential accumulation, knowledge structuring, design principles, infrastructure, software engineering practices, and the nuanced differences across business systems.

Backend DevelopmentScalable Systemssite scaling
0 likes · 31 min read
From Personal Homepage to Billion‑Page Site: Lessons in Scalable Web Architecture
MaGe Linux Operations
MaGe Linux Operations
Feb 20, 2016 · Fundamentals

How to Master Any New Technology Quickly: 5 Proven Steps for Engineers

The article outlines five practical steps—adopting a proactive mindset, shifting from passive to active learning, understanding the purpose of the technology, hands‑on experimentation with official quick‑start guides, deep‑dive reading, teaching, and community involvement—to help engineers rapidly master new IT tools and frameworks.

Technology adoptioncareer developmentcontinuous learning
0 likes · 9 min read
How to Master Any New Technology Quickly: 5 Proven Steps for Engineers
21CTO
21CTO
Feb 11, 2016 · Fundamentals

Why Strict Coding Standards Boost Productivity at Google

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.

Best PracticesGooglecode readability
0 likes · 7 min read
Why Strict Coding Standards Boost Productivity at Google
High Availability Architecture
High Availability Architecture
Jan 29, 2016 · Fundamentals

Evaluating Code Quality: Definitions, Readability, Maintainability and Practical Guidelines

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.

Best Practicescode qualitymaintainability
0 likes · 21 min read
Evaluating Code Quality: Definitions, Readability, Maintainability and Practical Guidelines
Alibaba Cloud Infrastructure
Alibaba Cloud Infrastructure
Jan 25, 2016 · R&D Management

Alibaba's Continuous Delivery Model and Practices for High‑Quality Software Delivery

The article explains Alibaba's continuous delivery theory, tools, and best‑practice pipeline—including integration, testing, deployment, and release—illustrated with diagrams and a detailed description of how the platform improves software quality, collaboration, and operational resilience in large‑scale cloud environments.

AlibabaCloud ComputingContinuous Delivery
0 likes · 11 min read
Alibaba's Continuous Delivery Model and Practices for High‑Quality Software Delivery
21CTO
21CTO
Jan 23, 2016 · Fundamentals

Are You Cut Out to Be a Programmer? Key Traits That Reveal Unsuitability

The article compiles insights from developers on Quora about the attitudes and habits—such as lack of patience, poor use of Google, 9‑to‑5 mindset, weak memory, giving up early on errors, focusing only on output, and missing enjoyment—that signal someone may struggle to succeed as a programmer.

career adviceprogrammer mindsetprogramming career
0 likes · 7 min read
Are You Cut Out to Be a Programmer? Key Traits That Reveal Unsuitability
Efficient Ops
Efficient Ops
Jan 22, 2016 · R&D Management

How Top Tech Experts Design Learning Plans and Master Their Craft

In this interview, senior technology specialist Yu shares practical strategies for creating effective learning plans, becoming an expert through deliberate practice, balancing full‑stack skills, choosing sustainable technologies, and overcoming growth plateaus in a fast‑changing software industry.

career developmentexpertisefull-stack
0 likes · 9 min read
How Top Tech Experts Design Learning Plans and Master Their Craft
Qunar Tech Salon
Qunar Tech Salon
Jan 22, 2016 · Fundamentals

My Journey Learning Data Structures and Algorithms

The article recounts the author's seven‑year path learning data structures and algorithms, from neglect in college to self‑study, book recommendations, internships at Microsoft and Baidu, projects such as a T‑SQL parser and a pinyin index, and reflections on the importance of algorithms.

AlgorithmsData StructuresInterview preparation
0 likes · 19 min read
My Journey Learning Data Structures and Algorithms
Qunar Tech Salon
Qunar Tech Salon
Jan 17, 2016 · Fundamentals

Google’s Code Quality Practices and the Myth of Code Age vs. Quality

The article examines how Google maintains high code quality through rigorous code reviews, strict style guides, active code‑health initiatives, fix‑it events, and a strong testing culture, while also discussing the perception that older code inevitably degrades.

Code ReviewGooglecode quality
0 likes · 5 min read
Google’s Code Quality Practices and the Myth of Code Age vs. Quality
21CTO
21CTO
Jan 16, 2016 · Fundamentals

Why Mastering Fundamentals Beats Chasing the Latest Tech

The author reflects on a programmer's focus on web, distributed systems, and data processing, arguing that deep, continuous investment in fundamentals—such as algorithms, networking, and OS concepts—drives lasting skill growth, better project outcomes, and a healthier professional mindset.

data-processingknowledge acquisitionprogramming fundamentals
0 likes · 8 min read
Why Mastering Fundamentals Beats Chasing the Latest Tech
21CTO
21CTO
Jan 16, 2016 · R&D Management

Turning a Resume Experiment into a Management Leap for a Software Engineer

This article recounts a career experiment where a senior software engineer named Bill reshaped his résumé to emphasize managerial experience, navigated two contrasting interview processes, and analyzes how social status and perceived leadership affect hiring outcomes in the tech industry.

InterviewManagementcareer
0 likes · 20 min read
Turning a Resume Experiment into a Management Leap for a Software Engineer
21CTO
21CTO
Jan 15, 2016 · Mobile Development

Mastering iOS App Architecture: Principles, Layering, and Common Folder Pitfalls

This article explores the essential concerns of iOS client‑app architecture—including network API handling, page presentation, local persistence, and dynamic deployment—while offering a step‑by‑step methodology, insights on layer design, and a critical look at the drawbacks of using a generic Common folder.

App ArchitectureMobile DevelopmentModular Design
0 likes · 26 min read
Mastering iOS App Architecture: Principles, Layering, and Common Folder Pitfalls
High Availability Architecture
High Availability Architecture
Jan 13, 2016 · Fundamentals

Bad Code: Causes, Symptoms, and Refactoring Challenges (Part 1)

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.

Best Practicesbad codecode quality
0 likes · 15 min read
Bad Code: Causes, Symptoms, and Refactoring Challenges (Part 1)
Qunar Tech Salon
Qunar Tech Salon
Dec 29, 2015 · Artificial Intelligence

Technical Debt in Machine Learning Systems

The paper examines how machine‑learning systems inherit unique forms of technical debt—such as boundary erosion, entanglement, hidden feedback loops, and data‑dependency issues—and discusses mitigation strategies, measurement techniques, and cultural changes needed to maintain sustainable, reliable ML deployments.

Machine LearningTechnical debtdata dependencies
0 likes · 26 min read
Technical Debt in Machine Learning Systems
Qunar Tech Salon
Qunar Tech Salon
Dec 27, 2015 · Fundamentals

The Importance of Continuous Learning in a Software Development Career

The author, a programmer with 32 years of experience, argues that continuous self‑education and staying abreast of emerging technologies are personal responsibilities, not the employer’s, illustrating this through a series of career anecdotes spanning from early microcomputers to modern mobile and web development.

career developmentcontinuous learningprogramming languages
0 likes · 11 min read
The Importance of Continuous Learning in a Software Development Career
Qunar Tech Salon
Qunar Tech Salon
Dec 26, 2015 · Fundamentals

Why Naming Is the Top Programming Challenge According to a Developer Survey

A developer survey of 4,500 programmers reveals that naming variables, classes, and functions is perceived as the biggest programming challenge, highlighting its impact on code readability, design quality, and maintenance, and underscoring the art and difficulty of choosing concise, meaningful identifiers.

code readabilitydeveloper surveynaming
0 likes · 6 min read
Why Naming Is the Top Programming Challenge According to a Developer Survey
Qunar Tech Salon
Qunar Tech Salon
Dec 23, 2015 · Fundamentals

Writing Impervious Code: Proper Use of If‑Else, Error Handling, Null Safety, and Avoiding Over‑Engineering

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.

Best PracticesError HandlingNull Safety
0 likes · 21 min read
Writing Impervious Code: Proper Use of If‑Else, Error Handling, Null Safety, and Avoiding Over‑Engineering
Qunar Tech Salon
Qunar Tech Salon
Dec 22, 2015 · Fundamentals

Programming Philosophy: Writing Elegant, Modular, and Readable Code

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.

Best PracticesModular DesignProgramming Philosophy
0 likes · 27 min read
Programming Philosophy: Writing Elegant, Modular, and Readable Code
DevOps
DevOps
Dec 20, 2015 · Fundamentals

The Essence of Software Development and Engineering: Lessons from Levi's Jeans and Power Plants

This article uses historical and everyday analogies—from Levi Strauss’s gold‑rush jeans to a simple power‑plant demonstration—to explain the core nature of software development, why traditional factory‑style management fails, and how agile practices, continuous integration, and quality standards drive modern software engineering.

qualitysoftware engineering
0 likes · 10 min read
The Essence of Software Development and Engineering: Lessons from Levi's Jeans and Power Plants
Efficient Ops
Efficient Ops
Dec 18, 2015 · R&D Management

Mastering Team Collaboration: Key Lessons from "The Geek and the Team"

This article summarizes the core concepts of "The Geek and the Team", highlighting humility, respect, and trust as pillars for effective software team collaboration, and provides practical guidance on culture, leadership, handling disruptive members, organizational influence, and user relationships.

LeadershipR&D Managementsoft skills
0 likes · 13 min read
Mastering Team Collaboration: Key Lessons from "The Geek and the Team"
DevOps
DevOps
Dec 18, 2015 · Fundamentals

The Essence of Software Development: Lessons from Levi’s Jeans and Engineering

This article uses historical and everyday analogies—such as Levi’s jeans and car factories—to explain the core principles of software development, emphasizing continuous design, iterative production, quality, efficiency, and the need for agile engineering practices.

Agile DevelopmentEfficiencycontinuous integration
0 likes · 9 min read
The Essence of Software Development: Lessons from Levi’s Jeans and Engineering
21CTO
21CTO
Dec 14, 2015 · Fundamentals

Mastering Clean Code: Practical Tips for Writing Elegant and Maintainable Software

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.

Best PracticesCode RefactoringModular Design
0 likes · 27 min read
Mastering Clean Code: Practical Tips for Writing Elegant and Maintainable Software
21CTO
21CTO
Dec 14, 2015 · Fundamentals

Why Continuous Learning Is a Programmer’s Survival Skill

The article reflects on a veteran programmer’s 32‑year journey, emphasizing that staying current through self‑driven education, exploring new languages and technologies, and not relying on employers for training is essential for long‑term success in the ever‑evolving software industry.

career developmentcontinuous learningprogramming
0 likes · 10 min read
Why Continuous Learning Is a Programmer’s Survival Skill
21CTO
21CTO
Dec 14, 2015 · Fundamentals

How to Write Bulletproof Code: Mastering If Statements, Error Handling, and Null Safety

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.

Best PracticesError HandlingNull Safety
0 likes · 21 min read
How to Write Bulletproof Code: Mastering If Statements, Error Handling, and Null Safety
21CTO
21CTO
Nov 30, 2015 · Fundamentals

9 Bad Programming Habits We Secretly Love (And Why They Persist)

While many developers know they should avoid certain coding shortcuts, this article reveals nine surprisingly common bad programming habits—like using goto, skipping documentation, over‑compressing code, and redefining operators—that programmers often cling to, explaining their origins, risks, and occasional hidden benefits.

Gotobad practicescode quality
0 likes · 14 min read
9 Bad Programming Habits We Secretly Love (And Why They Persist)
21CTO
21CTO
Nov 29, 2015 · R&D Management

Why Looking Busy Can Be a Bad Sign for Software Teams

The article argues that visible over‑time and frantic activity often mask poor software design, while quieter teams that focus on solid architecture, SOLID principles, and unit testing deliver higher quality code, challenging traditional notions of effort in tech management.

code qualityproductivitysoftware development
0 likes · 7 min read
Why Looking Busy Can Be a Bad Sign for Software Teams
21CTO
21CTO
Nov 21, 2015 · Backend Development

How to Become a Successful Web Architect: Essential Skills & Roadmap

This article outlines the common pitfalls programmers face on the path to web architecture, emphasizes mastering object‑oriented fundamentals, design patterns, and refactoring, and provides a detailed roadmap of the technical, operational, and managerial knowledge required to become a competent web architect.

Backend DevelopmentDesign Patternscareer development
0 likes · 19 min read
How to Become a Successful Web Architect: Essential Skills & Roadmap
21CTO
21CTO
Nov 17, 2015 · R&D Management

5 Essential Lessons for Veteran Programmers to Stay Relevant

A seasoned programmer in his late fifties shares five practical pieces of advice—ranging from staying true to your roots and embracing chaos to pruning code, leveraging experience, and prioritizing health—to help aging developers remain productive and fulfilled in the fast‑moving software industry.

career advicecontinuous learningsenior developers
0 likes · 14 min read
5 Essential Lessons for Veteran Programmers to Stay Relevant
21CTO
21CTO
Nov 14, 2015 · Fundamentals

How to Write Self‑Describing Code: Naming Best Practices for Clean Code

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.

Best Practicesclean codecode readability
0 likes · 8 min read
How to Write Self‑Describing Code: Naming Best Practices for Clean Code
21CTO
21CTO
Nov 13, 2015 · Fundamentals

How to Write Self‑Describing Code: Naming Best Practices for Clean Code

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.

Best Practicesclean codecode naming
0 likes · 9 min read
How to Write Self‑Describing Code: Naming Best Practices for Clean Code
21CTO
21CTO
Nov 7, 2015 · Fundamentals

Satirical Timeline: From Jacquard Loom to JavaScript

This tongue‑in‑cheek chronicle traces the evolution of programming languages—from the 1801 Jacquard loom’s punched‑card instructions and Ada Lovelace’s theoretical algorithm, through Turing’s universal machine, the birth of FORTRAN, Lisp, COBOL, C, Java, and up to modern JavaScript—mixing factual milestones with satirical commentary.

historyprogramming languagessatire
0 likes · 21 min read
Satirical Timeline: From Jacquard Loom to JavaScript