Tagged articles
1752 articles
Page 18 of 18
21CTO
21CTO
Nov 6, 2015 · Fundamentals

What Are the 8 Programmer Career Levels? A Global Perspective

This article outlines eight distinct programmer career levels—from the "Immortal Programmer" to the "Terrible Programmer"—explaining their characteristics, typical roles, and examples, while highlighting cultural differences in career expectations between China and abroad.

Industry Insightcareer levelsprofessional development
0 likes · 6 min read
What Are the 8 Programmer Career Levels? A Global Perspective
Qunar Tech Salon
Qunar Tech Salon
Oct 27, 2015 · Fundamentals

How to Define a Programmer and Advance Your Career

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.

Best Practicescareer developmentpersonal branding
0 likes · 11 min read
How to Define a Programmer and Advance Your Career
21CTO
21CTO
Oct 26, 2015 · R&D Management

A Day in the Life of a Google Engineer vs a Harvard Professor

Matt Welsh, a former Harvard CS professor now at Google, details his typical workday at both institutions, highlighting the stark contrast in coding time, meetings, and personal routines, offering insight into modern software engineering and academic life.

GoogleHarvardMatt Welsh
0 likes · 11 min read
A Day in the Life of a Google Engineer vs a Harvard Professor
21CTO
21CTO
Oct 26, 2015 · Fundamentals

What Terrible Code Practices Are Killing Your .NET Project?

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.

Best PracticesCDesign Patterns
0 likes · 9 min read
What Terrible Code Practices Are Killing Your .NET Project?
21CTO
21CTO
Oct 23, 2015 · R&D Management

How Tech Experts Can Transform into Effective Technical Managers

This article explores why technical experts often lack management experience, outlines the typical career stages of a developer, and provides practical guidance on shifting mindset, setting team goals, allocating resources, improving communication, and fostering empowerment to become successful technical managers.

Technical Managementcareer developmentmanagement skills
0 likes · 9 min read
How Tech Experts Can Transform into Effective Technical Managers
21CTO
21CTO
Oct 21, 2015 · Fundamentals

What Sets Top US Engineers Apart? Insights on Communication, Problem‑Solving, and Passion

The author compares Chinese and US software engineers, highlighting stark differences in communication style, problem‑solving ability, technical depth, passion for coding, and broader expectations such as leadership and vision, while noting that only a small elite in each country truly excel.

communicationcultural differencesproblem solving
0 likes · 8 min read
What Sets Top US Engineers Apart? Insights on Communication, Problem‑Solving, and Passion
21CTO
21CTO
Oct 19, 2015 · Fundamentals

Mastering C++ Naming Conventions: 8 Principles for Clear, Readable Code

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.

Best PracticesC++code readability
0 likes · 8 min read
Mastering C++ Naming Conventions: 8 Principles for Clear, Readable Code
21CTO
21CTO
Oct 19, 2015 · Fundamentals

18 Essential Programming Principles Every Developer Should Follow

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.

Best Practicesclean codeprogramming principles
0 likes · 8 min read
18 Essential Programming Principles Every Developer Should Follow
Qunar Tech Salon
Qunar Tech Salon
Oct 17, 2015 · Fundamentals

Lessons from Dennis Ritchie: The Birth of UNIX and the Power of Sharing

The article reflects on Dennis Ritchie's legacy, describing how his work on UNIX and the C language emerged from curiosity, stepping out of comfort zones, innovative thinking, and a philosophy of sharing that still influences modern software development and open‑source culture.

C languageDennis Ritchiecomputer history
0 likes · 5 min read
Lessons from Dennis Ritchie: The Birth of UNIX and the Power of Sharing
Efficient Ops
Efficient Ops
Oct 15, 2015 · Operations

Is DevOps & Full‑Stack Hype Killing Developers? A Critical Analysis

The article critically examines how the DevOps and full‑stack trends, driven by startup culture, force developers to juggle multiple roles, leading to overwork, reduced focus, and higher costs, while also highlighting nine companies that successfully practice DevOps.

DevOpsOperationsdeveloper roles
0 likes · 16 min read
Is DevOps & Full‑Stack Hype Killing Developers? A Critical Analysis
Qunar Tech Salon
Qunar Tech Salon
Oct 12, 2015 · R&D Management

How Programmers Can Build Their Personal Brand

Programmers can strengthen their personal brand by showcasing products, leveraging company and team reputation, contributing to open‑source, maintaining technical blogs, publishing books, obtaining patents and certificates, and cultivating a solid reputation, all of which enhance visibility and career opportunities.

career developmentpersonal brandingsoftware engineering
0 likes · 11 min read
How Programmers Can Build Their Personal Brand
Java High-Performance Architecture
Java High-Performance Architecture
Oct 10, 2015 · Fundamentals

Master the Software Iron Triangle: How Thoughtful Design Boosts Speed, Cost, and Quality

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.

Best Practicesdesigniron triangle
0 likes · 2 min read
Master the Software Iron Triangle: How Thoughtful Design Boosts Speed, Cost, and Quality
Qunar Tech Salon
Qunar Tech Salon
Oct 8, 2015 · Operations

Google’s 2‑Billion‑Line Codebase and the Piper Version‑Control System

The article examines Google’s massive 2 billion‑line code repository, compares its size to Windows, explains how the single‑repo approach and the Piper version‑control system enable thousands of engineers to collaborate across data centers, and discusses the broader impact on software engineering practices.

Code RepositoryGooglePiper
0 likes · 7 min read
Google’s 2‑Billion‑Line Codebase and the Piper Version‑Control System
21CTO
21CTO
Oct 4, 2015 · Fundamentals

Why I Gave Up on Coding Standards: Embracing Developer Freedom

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.

Best Practicescoding standardsdeveloper autonomy
0 likes · 6 min read
Why I Gave Up on Coding Standards: Embracing Developer Freedom
21CTO
21CTO
Sep 25, 2015 · R&D Management

The Legend of Alibaba’s Solo Engineer: How ‘Duo Long’ Built Core Systems Alone

A former Alibaba insider recounts how the enigmatic engineer known as ‘Duo Long’—a non‑technical graduate turned P11 senior leader—single‑handedly designed and maintained critical systems like TFS, Tair, cache, and search, embodying relentless focus, self‑learning, and a true craftsman spirit.

AlibabaR&DSystem Design
0 likes · 7 min read
The Legend of Alibaba’s Solo Engineer: How ‘Duo Long’ Built Core Systems Alone
Qunar Tech Salon
Qunar Tech Salon
Sep 25, 2015 · Fundamentals

Why Maintainability Should Be the Primary Goal of Software Architecture

The article argues that without clear evaluation standards, software architecture should be judged by how well it achieves the architect's design goals, emphasizing maintainability as the key criterion to balance performance, security, scalability, cost, and long‑term evolution.

Software Architecturedesign goalsmaintainability
0 likes · 12 min read
Why Maintainability Should Be the Primary Goal of Software Architecture
Qunar Tech Salon
Qunar Tech Salon
Sep 24, 2015 · Fundamentals

Performance vs. Maintainability: Why Maintainability Should Take Precedence

The article argues that while performance is important, maintainability is more critical for sustainable software development, illustrating this with anecdotes, common misconceptions about optimization, and practical advice on balancing code readability, caching, and hardware considerations.

CachingOptimizationPerformance
0 likes · 15 min read
Performance vs. Maintainability: Why Maintainability Should Take Precedence
21CTO
21CTO
Sep 24, 2015 · Fundamentals

From Zero to Algorithm Mastery: My 7‑Year Journey and Lessons Learned

The author chronicles a seven‑year evolution from a clueless undergraduate to a seasoned programmer, detailing the books, courses, internships, and personal projects that shaped his understanding of data structures and algorithms, while debating the practical value of algorithmic knowledge in software development.

AlgorithmsData StructuresLearning Resources
0 likes · 19 min read
From Zero to Algorithm Mastery: My 7‑Year Journey and Lessons Learned
21CTO
21CTO
Sep 23, 2015 · Fundamentals

What Do the Top 1% Software Engineers Do Differently? Four Key Habits

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.

Best Practicescareer developmentproductivity
0 likes · 4 min read
What Do the Top 1% Software Engineers Do Differently? Four Key Habits
21CTO
21CTO
Sep 21, 2015 · Backend Development

What Can Three Kingdoms Heroes Teach Us About Building a Robust Web Framework?

Drawing parallels between Three Kingdoms figures and web framework components, the article explains how each module—from the entry point to data and cache layers—functions, offering practical insights into designing clear, maintainable, and high‑performance backend architectures for modern web applications.

Backend ArchitecturePerformanceWeb framework
0 likes · 9 min read
What Can Three Kingdoms Heroes Teach Us About Building a Robust Web Framework?
21CTO
21CTO
Sep 19, 2015 · Backend Development

Is the Full‑Stack Engineer a Myth? Why Hiring One Is Unrealistic

The article argues that the full‑stack developer role is largely a myth, explaining employers' unrealistic expectations, the ever‑growing skill stack, and why the term often masks a desire for "amazing people" rather than a clearly defined technical profile.

DevOpsfrontend developmentfull-stack
0 likes · 6 min read
Is the Full‑Stack Engineer a Myth? Why Hiring One Is Unrealistic
Qunar Tech Salon
Qunar Tech Salon
Sep 16, 2015 · Fundamentals

A Programming Language Is a System for Encoding, Naming, and Organizing Algorithms

The article explains that a programming language serves as a system to encode, name, and organize algorithms, discusses the misuse of the term “algorithm,” illustrates classic algorithms like Dijkstra’s and Euclid’s with code examples in Forth, PostScript, and Python, and emphasizes the DRY principle and efficiency concerns in software development.

AlgorithmsCode ExamplesDRY principle
0 likes · 8 min read
A Programming Language Is a System for Encoding, Naming, and Organizing Algorithms
21CTO
21CTO
Sep 16, 2015 · Fundamentals

7 Toxic Habits Every Software Engineer Must Break to Boost Efficiency

The article outlines seven common counterproductive habits—lack of passion, avoiding testing, ignoring usability, saying "no" too quickly, resisting learning, poor teamwork, and neglecting security—that hinder software engineers' productivity and offers expert insights on how to overcome them.

coding habitsproductivityprofessional development
0 likes · 8 min read
7 Toxic Habits Every Software Engineer Must Break to Boost Efficiency
21CTO
21CTO
Sep 12, 2015 · Fundamentals

How to Become a Self‑Taught Programmer: A Practical Roadmap for Beginners

This guide outlines a comprehensive learning strategy for new programmers, covering what to study, effective study methods, specialization, practical coding practice, sharing knowledge, and staying updated with industry trends to accelerate career growth.

Learning Resourcescareer developmentprogramming
0 likes · 15 min read
How to Become a Self‑Taught Programmer: A Practical Roadmap for Beginners
21CTO
21CTO
Sep 10, 2015 · Fundamentals

How to Fast‑Track Your Journey from Junior to Senior Programmer

The article outlines practical habits—using Google for research, setting SMART goals, managing code on GitHub, logging learning, reading regularly, and mastering shortcuts—to help programmers break through the advanced‑beginner plateau and accelerate toward senior expertise.

career developmentlearning habitsproductivity
0 likes · 6 min read
How to Fast‑Track Your Journey from Junior to Senior Programmer
Qunar Tech Salon
Qunar Tech Salon
Sep 9, 2015 · R&D Management

Improving Communication Between Engineers and Product Managers: Insights from Nicholas C. Zakas

The article examines why software engineers are often seen as hard to communicate with, shares Nicholas C. Zakas' experiences and analogies, and offers practical advice such as involving engineers early, minimizing interruptions, granting creative space, and providing timely appreciation to foster better collaboration.

R&D ManagementTeam Collaborationcommunication
0 likes · 6 min read
Improving Communication Between Engineers and Product Managers: Insights from Nicholas C. Zakas
21CTO
21CTO
Sep 8, 2015 · Fundamentals

Why Performance Should Never Sacrifice Maintainability in Code

The article argues that while programmers obsess over performance gains, maintainability is often more critical, illustrating this with C# LINQ vs Single/First debates, database design pitfalls, and the hidden costs of premature optimization, ultimately urging developers to prioritize readable, maintainable code and measure performance before refactoring.

COptimizationPerformance
0 likes · 12 min read
Why Performance Should Never Sacrifice Maintainability in Code
21CTO
21CTO
Sep 7, 2015 · Fundamentals

When Is Rewriting Code Worth It? Lessons on Cost, Risk, and Value

The article argues that rewriting already‑deployed code rarely adds real product value, incurs high costs and risks, and should only be considered when the existing system is so outdated that a fresh start is the only viable solution.

Product DevelopmentTechnical debtcode rewrite
0 likes · 6 min read
When Is Rewriting Code Worth It? Lessons on Cost, Risk, and Value
21CTO
21CTO
Aug 28, 2015 · R&D Management

From Code Monkey to Tech Director: 6 Career Stages Every Engineer Must Master

This guide walks software engineers through six career phases—from college student to tech director—offering practical advice on goal setting, choosing employers, early‑career pitfalls, management fears, and how to keep growing while avoiding common regrets.

LeadershipManagementTech Career
0 likes · 8 min read
From Code Monkey to Tech Director: 6 Career Stages Every Engineer Must Master
21CTO
21CTO
Aug 24, 2015 · Fundamentals

Why Mastering Fundamentals Is the Key to Becoming an Outstanding Programmer

The article argues that deep mastery of programming fundamentals, guided by classic textbooks and a focused career path, is essential for long‑term success, and it explains how personal branding, positioning, and promotion amplify a developer's professional impact.

Learning Resourcescareer advicepersonal branding
0 likes · 10 min read
Why Mastering Fundamentals Is the Key to Becoming an Outstanding Programmer
21CTO
21CTO
Aug 23, 2015 · Fundamentals

Why Engineers Should Be Project Partners, Not Just Code Monkeys

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.

Best PracticesCode RefactoringProject Management
0 likes · 8 min read
Why Engineers Should Be Project Partners, Not Just Code Monkeys
21CTO
21CTO
Aug 19, 2015 · Fundamentals

How to Master New Technologies Fast: A Practical Guide for Engineers

The article outlines a step‑by‑step approach for engineers to quickly learn new IT technologies—emphasizing proactive mindset, active learning, leveraging official documentation, hands‑on practice, and sharing knowledge to achieve mastery and stay competitive in a rapidly evolving industry.

Technology adoptioncareer developmentcontinuous learning
0 likes · 9 min read
How to Master New Technologies Fast: A Practical Guide for Engineers
21CTO
21CTO
Aug 18, 2015 · Fundamentals

How Can a Programmer Move from Good to Great? Proven Strategies

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.

Best Practicescareer developmentexpertise
0 likes · 4 min read
How Can a Programmer Move from Good to Great? Proven Strategies

Guidelines for Becoming a 100‑Point Programmer: Saying Yes/No, Building Knowledge, and Good Practices

The article offers practical advice for programmers to improve their professional growth by carefully evaluating tasks before saying yes, learning to say no when necessary, building a personal knowledge system, maintaining a big‑picture view, adhering to coding standards, conducting code reviews, and continuously learning business knowledge.

Code Reviewcareer developmentknowledge management
0 likes · 7 min read
Guidelines for Becoming a 100‑Point Programmer: Saying Yes/No, Building Knowledge, and Good Practices
21CTO
21CTO
Aug 14, 2015 · Fundamentals

The 9 Toughest Challenges Every Programmer Faces

This article lists and explains the nine most frustrating tasks programmers encounter—from designing solutions and writing tests to naming variables—highlighting each task's difficulties and featuring candid comments from developers about their daily struggles.

codingdeveloper pain pointsprogramming challenges
0 likes · 9 min read
The 9 Toughest Challenges Every Programmer Faces
21CTO
21CTO
Aug 12, 2015 · Fundamentals

Why Humility Is the Key to Becoming a Great Programmer

The article argues that humility, honest self‑assessment, and the willingness to admit ignorance are essential personal traits for programmers, enabling them to manage mental fatigue, reduce errors, and continuously improve beyond their current abilities.

Personal Developmenthumilitymindset
0 likes · 5 min read
Why Humility Is the Key to Becoming a Great Programmer
ITPUB
ITPUB
Jun 14, 2015 · Fundamentals

Six Practical Naming Principles Every Programmer Should Follow

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.

Best Practicescode readabilitynaming conventions
0 likes · 4 min read
Six Practical Naming Principles Every Programmer Should Follow

Why Pair Programming Is Hard to Adopt and How to Implement It Effectively

This article examines the common obstacles that prevent teams from adopting pair programming, outlines the substantial benefits such as higher code quality and team cohesion, and provides practical strategies and step‑by‑step methods for introducing pair programming in both co‑located and distributed software development teams.

pair programmingsoftware developmentsoftware engineering
0 likes · 16 min read
Why Pair Programming Is Hard to Adopt and How to Implement It Effectively
Qunar Tech Salon
Qunar Tech Salon
Apr 11, 2015 · R&D Management

Building a Code Review Culture at Tencent: Lessons from Rietveld, Google C++ Style, and Organizational Practices

This article recounts how Tencent’s advertising team introduced and scaled a rigorous code review process—starting with the Rietveld system, adopting Google C++ coding style, and establishing metrics and ownership—to improve code quality, knowledge sharing, and engineering efficiency across multiple departments.

Code ReviewGoogle styleProcess Improvement
0 likes · 17 min read
Building a Code Review Culture at Tencent: Lessons from Rietveld, Google C++ Style, and Organizational Practices
Qunar Tech Salon
Qunar Tech Salon
Mar 12, 2015 · Fundamentals

Programming Skill Levels and Domain Knowledge Hierarchy

The article outlines a two‑dimensional model of programmer development, describing progressive stages of coding skill—from non‑programmer to language expert—and parallel levels of domain knowledge, while discussing paradigms, design patterns, architecture, and practical advice for advancing in software engineering.

Design PatternsSoftware Architecturedomain knowledge
0 likes · 26 min read
Programming Skill Levels and Domain Knowledge Hierarchy

Defining Software Architecture: Insights from Grady Booch, James Rumbaugh, and Ivar Jacobson

Software architecture is described as a set of critical decisions about system organization, including the selection of components, their interfaces, and collaborative behavior, and as a compositional style that progressively assembles these elements into larger subsystems, a definition comprehensively presented by Booch, Rumbaugh, and Jacobson in the UML User Guide.

System DesignUMLarchitecture fundamentals
0 likes · 1 min read
Defining Software Architecture: Insights from Grady Booch, James Rumbaugh, and Ivar Jacobson
Baidu Tech Salon
Baidu Tech Salon
Nov 13, 2014 · Fundamentals

17 Principles for Software Developers: Career Lessons and Best Practices

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.

Best Practicescareer adviceprofessional growth
0 likes · 8 min read
17 Principles for Software Developers: Career Lessons and Best Practices
Baidu Tech Salon
Baidu Tech Salon
Oct 9, 2014 · Fundamentals

The Norris Constant and the 20,000 Line Bottleneck

The article explains the Norris constant—initially 1,500 lines, later 2,000 and 20,000—as a practical bottleneck where novice programmers’ code becomes unmanageable, arguing that disciplined design, simplicity, and strategic “no” decisions are essential to break these limits and sustain large‑scale software.

code complexityprogrammingprogramming bottlenecks
0 likes · 9 min read
The Norris Constant and the 20,000 Line Bottleneck
Baidu Tech Salon
Baidu Tech Salon
Sep 17, 2014 · Industry Insights

Why the U.S. Tech Job Market Has Low Barriers for Programmers – A Comparative Insight

The article compares the low entry thresholds and favorable work environments for programmers in the United States with the stricter conditions in China, analyzes why many self‑proclaimed experts lack deep knowledge, and offers practical advice for individuals and companies to thrive in today’s software industry.

Industry InsightsUS tech industrycareer advice
0 likes · 8 min read
Why the U.S. Tech Job Market Has Low Barriers for Programmers – A Comparative Insight
Baidu Tech Salon
Baidu Tech Salon
Sep 1, 2014 · R&D Management

How to Tame a Chaotic Codebase When Scaling Your Startup

The article shares a founder’s hard‑earned lessons on preventing code‑base entropy, hiring the right first engineer, and gradually improving code quality so that a growing startup can transition from a solo coder to a well‑structured engineering team.

R&D Managementcode organizationsoftware engineering
0 likes · 7 min read
How to Tame a Chaotic Codebase When Scaling Your Startup
Baidu Tech Salon
Baidu Tech Salon
Jul 23, 2014 · Fundamentals

Guidelines for Refactoring and Cleaning Up Legacy Code

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.

Best PracticesCode RefactoringLegacy Code
0 likes · 14 min read
Guidelines for Refactoring and Cleaning Up Legacy Code
Baidu Tech Salon
Baidu Tech Salon
Jul 15, 2014 · Industry Insights

14 Legendary Programmers Who Shaped Modern Computing

This article profiles fourteen of the most influential programmers, detailing their key contributions, awards, and the high praise they receive from peers, offering a concise overview of the individuals who have driven major advances in software, algorithms, and open‑source technology.

Industry InsightsOpen Sourcealgorithm competitions
0 likes · 12 min read
14 Legendary Programmers Who Shaped Modern Computing
Baidu Tech Salon
Baidu Tech Salon
May 22, 2014 · Fundamentals

Reflections on Clojure: Design, Simplicity, and Development Flow

After years of using Ruby, I discovered that Clojure’s carefully designed, concise, and functional nature not only makes prototyping feel natural but also provides instant feedback and encourages thoughtful refactoring, turning development into a smooth, enjoyable flow that has quickly become my favorite language.

ClojureFunctional ProgrammingLanguage Design
0 likes · 8 min read
Reflections on Clojure: Design, Simplicity, and Development Flow
Baidu Tech Salon
Baidu Tech Salon
Apr 18, 2014 · Industry Insights

What Can Programmers Learn from Doctors? Professionalism Lessons for Developers

The article compares programmers to doctors, arguing that both solve problems with rational methods, and outlines three core principles—dedication before enjoyment, rigorous attitude, and a willingness to share—to help developers elevate their professionalism and deepen their problem‑solving capabilities.

Industry Insightscareer developmentprogrammer professionalism
0 likes · 6 min read
What Can Programmers Learn from Doctors? Professionalism Lessons for Developers