Tagged articles
software fundamentals
32 articles · Page 1 of 1
The article presents a concise learning roadmap that condenses four years of computer science curricula into ten essential books, each mapped to a specific layer of system architecture—from hardware and operating systems to algorithms, distributed systems, and AI—helping students and professionals build a complete foundational knowledge base without fragmented short‑video learning.
Learning Roadmapclassic bookscomputer science
0 likes · 9 min read

The article surveys ten historically influential programming languages—COBOL, ALGOL, APL, BASIC, PL/I, SIMULA, Pascal, CLU, ML, and Smalltalk—explaining their original purposes, key technical contributions, reasons they fell out of mainstream use, and how their ideas continue to underpin today’s software ecosystems.
ALGOLAPLCOBOL
0 likes · 12 min read

This guide demystifies Git by exposing common myths, presenting the 35 most useful commands organized by daily workflow, undo scenarios, branching, and advanced tricks, and offering a step‑by‑step 30‑day learning plan, mental models, common pitfalls, and tool recommendations to boost confidence and productivity.
GitWorkflowbeginner guide
0 likes · 17 min read


21CTODec 29, 2025 · Fundamentals
This article explores the history and cultural significance of the "Hello World" program, presents concise implementations across dozens of programming languages, and compares their execution times in a single‑core sandbox, highlighting Bash as the quickest and Kotlin as the slowest.
Code Exampleshello-worldperformance comparison
0 likes · 8 min read


21CTOFeb 22, 2025 · Artificial Intelligence
The article examines how reliance on AI tools like Copilot and GPT accelerates code delivery but erodes fundamental understanding, urging developers to adopt a learning mindset, engage with community discussions, and balance speed with deep comprehension.
AI in developmentCopilotDeveloper Productivity
0 likes · 7 min read


21CTOFeb 2, 2025 · Fundamentals
This article shares seven practical habits—from mastering fundamentals and writing clean code to debugging effectively and building real‑world projects—that help programmers become more skilled, professional, and collaborative in their development journey.
Clean CodeDebugginglearning documentation
0 likes · 8 min read

The article traces BASIC’s origins, recounts personal experiences with early BASIC dialects, and argues that Python has become the contemporary equivalent of BASIC by offering an accessible, ubiquitous, and versatile language for non‑programmers, while also acknowledging its drawbacks.
BASICLanguage comparisonprogramming history
0 likes · 7 min read

The article explains core software design patterns, the benefits and pitfalls of layered architecture, essential database and transaction practices, and concurrency control techniques such as isolation, immutability, optimistic and pessimistic locking, guiding developers to build robust enterprise systems.
Layered ArchitectureTransactionsdesign patterns
0 likes · 10 min read

This article explains why garbage collection (GC) is essential, defines key GC terminology, compares performance metrics, and provides a detailed overview of seven common GC algorithms—including mark‑sweep, reference counting, copying, mark‑compact, conservative, generational, and incremental GC—along with their advantages, disadvantages, and typical improvements.
GC algorithmsmemory managementsoftware fundamentals
0 likes · 47 min read

Design patterns and algorithms remain external to official language specifications because they need universal applicability, flexibility for innovation, and manageable maintenance, and developers can visualize them with UML diagrams—such as the Observer pattern class diagram—to better understand and implement these core software concepts.
UMLprogramming languagessoftware fundamentals
0 likes · 4 min read

This article explains why maintaining clean, readable code is crucial for team productivity, covering the impact of messy code, practical guidelines for naming, class design, function structure, and testing practices such as TDD and the FIRST principles, all illustrated with real code examples.
Clean CodeTDDclass design
0 likes · 15 min read

The article recounts how early programmers wrote code on switch‑based computers without keyboards, monitors, or IDEs, manually entering assembly in memory, using paper tape and punch cards, and eventually witnessing the emergence of BASIC, Unix, and early networking, illustrating the evolution of software development practices.
assembly languagecomputing evolutionearly computers
0 likes · 5 min read

This article recounts Ken Thompson’s 1975 teaching stint at Berkeley, the emergence of Bill Joy’s contributions to Unix, and explains vi/vim’s core command structure—operators, motions, and modifiers—illustrating how mastering these fundamentals transforms the editor from daunting to powerful.
CommandViVim
0 likes · 7 min read

The article explains that finding LeetCode problems difficult is common, discusses the necessity of algorithm practice for interviews, and offers a structured, incremental learning method to improve coding skills while maintaining motivation.
LeetCodealgorithm practicecoding interview
0 likes · 8 min read

The article describes four distinct code‑hygiene personalities—Minimalist, Distance‑Creates‑Beauty, Precise‑Constraint, and Creative‑Craft—explaining how each habit improves code readability, reduces technical debt, and ultimately boosts team efficiency in software projects.
Clean Codecode hygieneprogramming habits
0 likes · 2 min read

This article explores the challenges of business architecture, explaining how abstract design patterns can be concretized to create tangible value for enterprises, and presents visual diagrams that illustrate the core concepts and practical application of business architecture.
Business Architectureenterprise architecturesoftware fundamentals
0 likes · 2 min read

This article explains why understanding the underlying logic of design patterns—identifying change and encapsulating it—is essential for writing flexible, maintainable code, and shows how this principle applies to both software architecture and real‑world business scenarios.
EncapsulationObject-Oriented Designdesign patterns
0 likes · 15 min read

This article explains why mastering the underlying logic of design patterns—recognizing what changes and how to encapsulate those changes—is essential for developers to select appropriate patterns, improve object‑oriented design, and solve real‑world software problems effectively.
Object-Oriented Designchange encapsulationsoftware architecture
0 likes · 15 min read

This article provides a comprehensive visual guide to Git's most common commands—add, commit, reset, checkout, merge, rebase, cherry‑pick, and more—explaining how they move files between the working directory, index, and repository while illustrating concepts such as HEAD, detached HEAD, and the underlying blob/tree storage model.
Workflowsoftware fundamentals
0 likes · 14 min read

This article explains the Decorator design pattern in Java, detailing its four core participants—Component, ConcreteComponent, Decorator, and ConcreteDecorator—through UML diagrams and complete code examples, and also illustrates how Java’s InputStream hierarchy uses FilterInputStream as a real‑world decorator.
Decorator PatternInputStreamJava
0 likes · 5 min read

This report outlines the fundamentals of computer operating systems, compares open‑source and closed‑source models such as Linux and Windows, examines the development costs, ecosystem challenges, and the strategic importance of domestic OS in China’s new‑infrastructure and information‑security landscape.
LinuxWindowsclosed source
0 likes · 16 min read


ITPUBApr 5, 2020 · Fundamentals
A massive SAP cloud application suffered a 20‑second pause due to an accidental wait statement, revealing how careless code can cripple performance and illustrating practical, step‑by‑step guidelines for effective, measured code optimization.
Compiler Flagscode optimizationcode review
0 likes · 11 min read

This guide explains Git's core workflow—adding, committing, and pushing—breaks down the four Git areas and five file states, shows how to inspect changes with various git diff commands, and provides step‑by‑step commands to undo modifications at each stage, all illustrated with practical examples.
Gitgit checkoutgit diff
0 likes · 8 min read

This article introduces programming paradigms—object‑oriented, procedural, functional, and imperative—explaining their definitions, underlying philosophies, and how each can be used to implement a simple calculator, while comparing their advantages and illustrating their conceptual relationships.
ProceduralProgramming Paradigmsfunctional programming
0 likes · 7 min read

The article outlines essential coding guidelines that emphasize optimizing code for readers rather than authors, keeping rules concise, valuing standards without fanaticism, ensuring consistency, providing clear cues for rare cases, and avoiding clever but hard‑to‑maintain constructs.
Best PracticesCode Readabilitycoding standards
0 likes · 2 min read


ITPUBJul 28, 2018 · Fundamentals
This article outlines why programmers should improve their self‑cultivation, defines the concept, and provides concrete methods—including mastering fundamentals, English, effective searching, business thinking, and disciplined coding habits—to become more competent and successful developers.
Self-Improvementcareer growthcoding habits
0 likes · 20 min read


21CTOJul 2, 2018 · Fundamentals
This article explores how developers can improve their coding by mastering collaboration skills such as pair programming and code reviews, cultivating patience and humility, and adopting solid fundamentals like reading code, design patterns, test‑driven development, and disciplined refactoring to produce cleaner, more maintainable software.
Coding Best PracticesCollaborationcode review
0 likes · 6 min read

A seasoned developer shares seven practical pieces of advice—covering health, hobbies, continuous learning, mindset, role flexibility, creativity, and hand speed—to help newcomers become healthier, more versatile, and more effective programmers.
career developmentcontinuous learninghealth
0 likes · 17 min read


21CTOJul 15, 2017 · Fundamentals
This article demystifies the common myth that programming requires advanced mathematics, outlining the essential arithmetic, number‑system concepts, and occasional higher‑level topics like geometry, physics, and cryptography, while showing how simple simulations can reveal the impact of small statistical changes.
Simulationmath for developerssoftware fundamentals
0 likes · 10 min read

This guide explains Git's origins, compares distributed and centralized version control, walks through creating a repository, adding and committing files, switching versions, and using reset, log, and reflog to recover previous states, providing practical command‑line examples for developers.
GitRepositorycommand-line
0 likes · 7 min read


21CTOOct 1, 2016 · Fundamentals
This article explores the evolution of programming languages, compares their core features such as syntax, error handling, and concurrency, and offers practical guidance on selecting and learning a language that will remain relevant for years, emphasizing historical context and hands‑on practice.
Language Learninglanguage historyprogramming languages
0 likes · 6 min read


21CTOJun 10, 2016 · Fundamentals
The article explains how discussing debugger implementation principles in interviews can uncover a candidate's fundamental computer knowledge, curiosity, and ability to understand runtime environments, helping identify both strong engineers and those with critical knowledge gaps.
candidate evaluationdebuggerinterview techniques
0 likes · 5 min read
