Tagged articles
modularity
22 articles · Page 1 of 1
The author reveals how elite programmers like nginx creator Igor Sysoev develop mastery through deliberate practice, learning from top engineers, contributing to open source, and tackling difficult valuable problems, noting that supporting diverse systems forces better design while modularity can hinder evolution.
Igor Sysoevcross-domain knowledgedeliberate practice
0 likes · 8 min read

The article explains how AI agents (decision‑makers) and skills (executors) form a five‑layer, seven‑role dispatch chain that turns a single user request into a sixteen‑step workflow, delivering modularity, reusability, safety, and progressive loading benefits.
AIAgentAnthropic
0 likes · 14 min read

The article first lists a series of Java learning projects and community benefits, then critically examines the widely touted advantages of microservices, showing how many of those claims originate from older technologies, debunking common myths, and concluding that microservices are essentially just modular code.
distributed systemsindustry analysismicroservices
0 likes · 16 min read

This article critically examines the popular claims surrounding microservices, tracing their historical roots, debunking each touted benefit, exposing distributed‑computing fallacies, and highlighting the real organizational challenges, ultimately concluding that microservices are simply modular components rather than a revolutionary architecture.
backend developmentdistributed systemsindustry analysis
0 likes · 15 min read

The article critically examines the hype around microservices, arguing that their true value lies in promoting modularity, clear ownership, and organizational clarity rather than solving inherent technical problems, and it traces these ideas back to classic software engineering principles and modern operational challenges.
distributed systemsmodularityscalability
0 likes · 22 min read

The article examines the role of independent (free) functions in object‑oriented programming, outlining how they can reduce complexity, improve reuse, and promote modularity while warning against overuse, namespace pollution, and the need to balance procedural and OOP approaches.
OOPcode reuseindependent functions
0 likes · 5 min read

This article explores the essential components of modern frontend architecture, covering concepts such as modularity, componentization, code organization, state management, network layer design, performance optimization, security measures, automated testing, and continuous deployment, with practical code examples in React, Vue, Redux, Axios, and GitHub Actions.
SecurityState Managementarchitecture
0 likes · 8 min read

The article explains that good software architecture must be deliberately designed and continuously refactored to combat entropy and the broken‑window effect, balancing behavior and architecture value while managing complexity through principles like Ockham’s razor, orthogonality, DRY, stable dependencies, layered abstractions, and clear boundaries, supported by UML visualizations.
ComplexityDRYDesign Principles
0 likes · 19 min read

This article explains the fundamentals of community detection in graph computing, contrasting it with clustering, describing key concepts such as modularity, and reviewing classic algorithms like Louvain, node2vec‑based methods, and Infomap, while highlighting their applications across domains.
Community DetectionGraph AlgorithmsInfomap
0 likes · 11 min read

This article introduces community detection as a fundamental graph algorithm, explains its basic concepts and types, compares it with clustering, discusses evaluation metrics like modularity, and reviews classic methods such as Louvain, node2vec‑based approaches, and the information‑theoretic Infomap algorithm.
Community DetectionGraph AlgorithmsInfomap
0 likes · 13 min read

The article reviews Liferay DXP’s latest capabilities—including modular architecture, semantic versioning, a shift from monolith to microservices, exposed services, faster page refresh via Senna.js SPA, broader tool support, and Java component reuse—highlighting benefits for developers and large‑scale deployments.
DXPLiferayOSGi
0 likes · 11 min read

This article critically examines the microservices movement, tracing its historical roots, debunking common hype, and arguing that the true value lies in modular design, clear team ownership, and disciplined architectural practices rather than merely scaling distributed systems.
distributed systemsmicroservicesmodularity
0 likes · 23 min read

The article analyzes current data‑warehouse development trends—standardization through data governance, real‑time processing via stream‑batch integration, modular architecture, and holistic performance evaluation—while linking these trends to emerging concepts such as data middle‑platforms, data lakes, and DataOPs.
data warehousemodularity
0 likes · 12 min read

The Louvain algorithm, a fast modularity‑maximizing community‑detection method, iteratively merges nodes into hierarchical super‑nodes, enabling anti‑fraud systems to uncover hidden collusive groups in weighted transaction graphs, thereby improving detection of fake orders, coupon abuse, and other illicit behaviors despite its iterative nature and streaming limitations.
Anti-FraudCommunity DetectionGraph Algorithms
0 likes · 10 min read

This article outlines nine practical Python coding habits—including early design, thorough documentation, consistent naming, code aesthetics, comprehensive README, modularization, version control, regular backups, and consulting official documentation—to help developers write clean, readable, and maintainable software.
Code ReadabilityCoding Best Practicesmodularity
0 likes · 8 min read

This article explains the concept of communities in graphs, illustrates Granovetter's weak tie theory, introduces the Louvain algorithm for modularity‑based community detection, and presents the overlapping‑community detection method BigCLAM built on the Community Affiliation Graph Model.
BigCLAMCommunity DetectionLouvain Algorithm
0 likes · 8 min read


DevOpsAug 24, 2020 · Fundamentals
This article explains the concept of loose coupling in banking IT systems, outlines its definitions, measurement criteria, and practical design guidelines across components, interfaces, data, and processes, while also discussing the trade‑offs and costs associated with adopting a loosely coupled architecture.
Loose Couplingbanking ITmodularity
0 likes · 16 min read

This article explores the fundamentals of logical architecture, covering basic constraints, common software design principles, design patterns, module reuse strategies, abstraction techniques, granularity trees, and practical layering approaches to help engineers build scalable, maintainable systems.
architecturedesign-patternsmodularity
0 likes · 33 min read

The article explains the Louvain community‑detection algorithm, detailing its modularity‑maximizing objective, two‑step iterative process, efficient graph data structures, practical implementation considerations, and performance results on large‑scale graphs, providing a comprehensive guide for practitioners.
Community Detectionc-implementationgraph algorithm
0 likes · 7 min read

The article examines the difficulties of developing and sustaining a multi‑million‑line C‑language database, highlighting complex flag‑driven logic, extensive testing pipelines, slow iteration cycles, and the need for automation, modularity, and robust engineering practices to ensure code quality at scale.
Database Engineeringautomationcode quality
0 likes · 6 min read


ITPUBOct 9, 2016 · Fundamentals
The article explains how the Linux kernel’s flexible architecture and highly modular design enable massive volunteer contributions, seamless extensibility, and cross‑platform portability by detailing its position in the system, core functions, subsystem interactions, key data structures, and the benefits of its layered, dependency‑driven design.
Process schedulerkernel architecturememory management
0 likes · 19 min read

The article explains how to design clean, decoupled system architectures by isolating concerns, using AOP, dependency injection, factory methods, and DSLs, while illustrating concepts with city‑building analogies and Java code examples.
AOPmodularitysoftware design
0 likes · 10 min read
