SpringBoot 3.2 and Spring Cloud 2023 are now supported by the PIG microservice, bringing JDK17/21 compatibility, virtual‑thread support, SSL hot‑reload, enhanced observability, and a host of dependency upgrades, while SpringBoot 2.x reaches end‑of‑maintenance.
This article explains the concept and inner workings of Spring Boot Starters, demonstrates how they simplify dependency management and auto‑configuration, and provides a step‑by‑step guide to creating and using a custom Starter with full code examples.
This guide walks you through installing Go, verifying the environment, initializing modules, managing dependencies, running and building programs, formatting code, cleaning unused packages, testing, and static analysis using core Go command‑line tools.
This article explains why component‑based architecture is essential for medium‑to‑large mobile applications, outlines common problems and benefits, and provides concrete guidelines on component granularity, dependency management, communication, quality assurance, and migration strategies.
This guide explains how to install the IDEA Maven Helper plugin, use its Dependency Analyzer to detect and exclude conflicting Maven dependencies, and provides alternative methods such as IDEA Diagrams and Maven commands for managing Java project dependencies.
This article explains the three main Maven dependency principles—shortest‑path priority, declaration order priority, and override priority—illustrates them with concrete examples and code snippets, describes common conflict errors, and outlines the complete Maven dependency loading workflow.
This article introduces Rome, a next‑generation frontend toolchain that unifies dependency management, code formatting, static type checking, building, and asset handling, and provides step‑by‑step installation, configuration, usage commands, and customization options, helping developers improve efficiency and code quality.
This article examines componentization as a project architecture for medium to large mobile applications, outlining its motivations, common challenges, design principles, component granularity, dependency management, communication methods, quality assurance practices, and the trade‑offs involved in adopting a component‑based approach.
Implementing micro‑applications for efficiency engineering using a monorepo and micro‑frontend approach, supported by tools like monopower, the company tackled dependency and coupling challenges, cutting migration time by 30% and halving maintenance costs while delivering a robust architecture, testing, and monitoring framework.
This article explains common Maven JAR dependency conflict scenarios and presents four practical solutions—including using Exclusions, configuring dependency scopes, applying the Maven Shade plugin for class relocation, and employing class‑loader isolation strategies—to help developers choose the appropriate method for their build and runtime environments.
This article explores the motivations, benefits, challenges, and practical guidelines for adopting a component‑based architecture in medium‑to‑large mobile applications, covering topics such as modular granularity, dependency management, communication patterns, version compatibility, quality assurance, and the trade‑offs of componentization versus monolithic projects.
This technical guide details how to set up iOS dependencies, publish KMM libraries, build a GitLab CI/CD pipeline, and resolve common integration problems for Kotlin Multiplatform Mobile projects, providing code examples and best‑practice recommendations for mobile developers.
The article examines Google’s single‑repository (monorepo) strategy, detailing its technical benefits such as unified version control, code sharing, and atomic changes, while also analyzing the substantial tooling, infrastructure, and maintenance costs, and discussing why alternatives like Git are not adopted.
The article explains that Python 3.7 will reach end‑of‑life in June 2023, outlines the risks of staying on an unsupported version, and provides a step‑by‑step migration path to newer Python releases to ensure security and dependency compatibility.
Upgrading from Python 3.7 is essential because the version reaches end‑of‑life in June 2023, losing security fixes and third‑party library support, so developers must plan a migration to newer, maintained releases to keep applications safe and functional.
This article explains how to handle Python environment and dependency management using pip tools such as pip list, pip freeze, pipdeptree, pip‑autoremove, and the conda ecosystem for creating isolated virtual environments, exporting configurations, and integrating with IDEs.
This article reviews the evolution of Node.js package managers—from npm2's nested dependencies to Yarn's flat model, npm3's symlink approach, and pnpm's content‑addressable store—highlighting their installation commands, advantages, drawbacks, and impact on disk usage and dependency management.
This article examines the drawbacks of multi‑repo development for large mobile apps, explains the concepts of monorepo and full‑source, and details ByteDance's BitSky implementation—including migration phases, Bazel build migration, dependency management, developer tools, and measurable efficiency gains.
The article details how Xianyu’s messaging team systematically improved system stability by classifying risks, implementing gray‑release traffic, establishing dedicated monitoring and alerting dashboards, integrating automated regression into CI/CD, and managing strong‑weak dependencies, ultimately reducing online incidents to near zero.
This article explains how adopting a MonoRepo strategy combined with pnpm's workspace feature can streamline front‑end project structures, reduce duplicate dependencies, improve version control, and eliminate ghost dependencies, ultimately speeding up development and release processes.
This article explains how npm, Yarn, and pnpm manage JavaScript dependencies, detailing installation processes, flat vs nested node_modules structures, lock files, and the hard-link mechanism that improves speed and saves disk space.
Spring Cloud 2021.0.6, built on Spring Framework 5.x and Spring Boot 2.7, introduces the latest stable release with Java 8 minimum, updated dependency management, enhancements across Commons, Netflix, Gateway, Kubernetes, OpenFeign, Stream, and Function modules, plus a Maven Central artifact and code snippet.
Since launching a systematic stability‑governance program in August 2022, Xianyu’s messaging system has employed gray releases, dedicated monitoring, daily automated regression, dependency reviews and drills, resulting in near‑zero online incidents within six months and demonstrating that continuous, context‑specific measures and vigilant change management are essential for reliable C2C transactions.
The pnpm 7.23 update introduces a workspace‑root peer‑resolution option, adds command‑line help entries for the -resum-from and -include-workspace-root flags, and continues to emphasize pnpm’s disk‑space‑saving content‑addressable store for Node.js projects.
This article examines the common perceived benefits of microservices, shows how many of them can be achieved with a well‑designed monolith, and provides concrete criteria and tactics for small, medium, and large teams to decide which architecture best fits their context.
Google’s open‑source OSV‑Scanner provides a powerful front‑end to the OSV vulnerability database, allowing developers to scan directories, SBOMs, and Docker images for known security issues across 16 ecosystems, outputting results in JSON or table format and supporting ignore rules for specific vulnerabilities.
Spring Cloud 2022.0.0, built on Spring Framework 6.x and Spring Boot 3.x, requires Java 17, introduces Jakarta EE support, marks OpenFeign as feature‑complete, and provides updated Maven dependency management details, while noting the end of OSS support in November 2023.
To eliminate duplicated checkout logic and cumbersome npm publishing, the team migrated multiple React Native apps into a Yarn‑workspace monorepo, configuring Metro watch folders, hoisting dependencies, and CI linting, while using git‑subtree for integration, achieving easier code reuse, debugging, and dependency management despite RN‑specific build complexities.
The article explains Gradle's dependency‑graph symbols—arrow (→) for version conflicts, (c) for constraint‑driven versions, (*) for omitted subtrees, and markers for strict or forced versions—showing how to read the output, identify conflicts, and apply proper resolution strategies.
This article explains common Maven commands, describes why a JAR built for execution cannot be imported by a third‑party project, and provides step‑by‑step solutions using the maven‑compiler‑plugin and maven‑assembly‑plugin to create dependency‑inclusive JARs.
This guide shows the original Maven dependency for the MySQL Connector/J library and provides the updated coordinates with the newer groupId, artifactId, and version, helping Java developers keep their projects up to date.
This article explains how npm installs dependencies, the role of package‑lock.json, the evolution from nested to flat node_modules structures, npm's caching strategy, and provides practical guidance for setting up a private npm registry and handling common installation issues.
Spring Boot 2.7.5 has been released with over 30 bug fixes and dependency upgrades, includes details on configuration comment detection, Kafka auto‑configuration changes, PEM certificate handling, and provides guidance on switching from the unavailable Alibaba Cloud Maven mirror to Tencent Cloud’s mirror.
This guide walks you through fixing Python environment variable issues and missing dependency errors when installing scientific libraries, offering step‑by‑step solutions and a reliable pip mirror command to ensure smooth installation.
This guide explains how to reduce Spring Boot jar size by separating third‑party dependencies from business code, configure Maven for dependency splitting, use Jenkins to detect changes via MD5 checks, and deploy the resulting packages through SSH or Docker‑based pipelines.
This article describes ByteDance's cloud‑based CocoaPods dependency analysis service, explaining its background, architecture, caching mechanisms, material pruning, and decision‑making strategies that together reduce iOS build dependency resolution time by over 60% while maintaining correctness and low integration cost.
This article introduces Gradle as a modern Java build tool, covering its installation methods, wrapper usage in IDEs, concise dependency configuration, task and plugin flexibility, mirror and proxy setup, and the performance and usability benefits compared to Maven.
This article shares sixteen practical Spring Boot best‑practice recommendations—ranging from custom BOMs and automatic configuration to clean controller design, constructor injection, externalized configuration, and comprehensive testing—to help developers create maintainable, scalable Java microservices.
Exploring Go 1.18, the article walks readers through its three flagship additions—generics, fuzzing, and workspaces—detailing installation, underlying implementation concepts, practical code examples, and how each feature enhances type safety, automated testing, and multi‑module dependency management for modern backend development.
This guide explains how to reliably manage Python project dependencies and environments using pip tools (pip list, pip freeze, pipdeptree, pip‑autoremove) and Conda (installation, virtual environments, environment export/import, IDE integration), helping you avoid common pitfalls as projects scale.
This guide explains a simple method to apply custom modifications to Composer packages by copying the needed files into a patches directory and configuring the post‑autoload‑dump script to automatically overwrite the original files during installation or update, avoiding the need for external tools.
This article explains the shortcomings of Maven, shows how to install Gradle (including package‑manager and wrapper methods), demonstrates Gradle wrapper usage in IDEA, compares dependency scopes, outlines task and plugin customization, provides mirror and proxy configuration, and lists the speed, flexibility and conciseness advantages that make Gradle a superior build tool for Java projects.
This article explains how to manage Python project dependencies using pip and conda, covering basic pip commands, dependency trees with pipdeptree, clean removal with pip‑autoremove, and creating, activating, and exporting isolated environments with Conda, including practical examples and best‑practice recommendations.
A frontend engineer tackles slow npm installs, massive disk usage, a buggy package causing infinite loops, and the need for security scanning by deploying a domestic mirror, using npm overrides, and adopting cnpmcore for enterprise‑grade package management.
Gradle offers a modern, flexible alternative to Maven for Java projects, with faster builds, concise Groovy scripts, powerful dependency scopes, easy installation via binaries, package managers, or the Gradle Wrapper, plus configurable mirrors and proxy settings, making it ideal for backend development workflows.
This guide explains why and how to assess the health of npm dependencies, outlines a step‑by‑step upgrade process, highlights tools like npm outdated, npm audit, depcheck, and offers practical advice on changelog review, lock‑file management, and distinguishing dependencies from devDependencies.
Gradle offers a faster, more flexible alternative to Maven for Java projects, with simple installation options, wrapper support, concise dependency syntax, powerful task scripting, easy mirror configuration, and superior performance, making it essential for modern backend development.
This guide introduces Poetry, a Python virtual‑environment and dependency manager, covering installation on macOS (including curl and pipx methods), project creation, virtual‑environment handling, configuring PyPI mirrors, common commands, and integrating Poetry with PyCharm, providing a complete workflow for Python developers.
This article presents a detailed collection of Spring Boot best practices—from custom BOM dependency management and automatic configuration to project initialization, code structure, logging, testing, and configuration externalization—providing actionable guidance for building robust, maintainable micro‑services in Java.
The article explains how software complexity arises from scale, structure, and change, and shows that controlling dependencies through bounded contexts and aggregates—by reducing dependency quantity and weakening dependency strength—provides a practical way to achieve high cohesion and low coupling in system architecture.
The article explains how software complexity stems from scale, structure, and change, and shows that controlling dependencies—by reducing their number and weakening their strength—through bounded contexts and aggregates is the key to achieving high cohesion and low coupling in domain‑driven design.
The article explains why and how to store external libraries and tools in a private artifact repository, isolate builds from the internet, and verify build stability by testing offline pipelines, emphasizing the importance of managing dependencies for reliable DevOps processes.
The article reviews the fifteen dependency‑management guidelines, discusses how to apply them in practice, and lists both open‑source and commercial tools—including Google’s Open Source Insights, Snyk, WhiteSource, Fossas, Anchore, OpenSCA, and MurphySec—while also highlighting differing analysis strategies and related research reports.
This article presents a comprehensive set of fifteen best‑practice guidelines—nine pre‑inclusion checks and six post‑inclusion usage rules—covering design review, code quality, automated testing, debugging, licensing, transitive dependencies, security, and upgrade strategies to ensure a robust and secure software supply chain.
This article explains the critical importance of managing software dependencies, outlines the risks of blindly using external packages, shares lessons from a Golang mob code‑review session, and provides practical guidelines for selecting, using, and monitoring dependencies in modern development.
This article presents fifteen practical guidelines for managing software dependencies, covering pre‑inclusion checks such as design review, code quality, testing, security, licensing, and transitive dependencies, as well as post‑use practices like encapsulation, isolation, update strategies, and continuous monitoring to maintain a secure and reliable supply chain.
This article explains the critical role of dependency management in modern software development, illustrates common risks with real‑world examples, defines what a dependency is, describes package managers, and provides practical guidelines for selecting and using external packages safely.
Youku tackled explosive module growth and tangled dependencies by decomposing its iOS app into independent, Xcode‑based plugins that define modules and relationships, dramatically speeding compilation, enabling hot‑reload and simulator builds, cutting disk usage, and improving debugging, monitoring, and specialized app development.
This article examines the development of npm, describing its early nested dependency model in v1/v2, the flat‑dependency approach introduced in v3, and the package‑lock enhancements of v5, while highlighting the advantages and new challenges each version brought to Node.js package management.
This article analyses the evolution of front‑end package managers—from npm's early nested modules to Yarn's lockfile and Plug'n'Play, pnpm's hard‑link strategy, cnpm/tnpm adaptations, and Deno's URL‑based imports—highlighting their dependency resolution mechanisms, trade‑offs, and remaining challenges.
This comprehensive tutorial explains why Maven is essential for Java projects, walks through installation, project structure, common commands, repository management, dependency scopes, lifecycle phases, Eclipse integration, and advanced features, providing code examples and visual diagrams for clear understanding.
This article examines how npm, Yarn, pnpm, cnpm, tnpm and Deno handle dependency installation, version locking, flattening, and module resolution, highlighting the evolution from nested node_modules to lockfiles and Plug'n'Play, and discusses the trade‑offs of each approach.
This article examines how npm, Yarn, pnpm, cnpm, tnpm, and Deno handle dependency installation, version locking, and node_modules structures, highlighting the evolution from nested to flattened layouts, the emergence of phantom and multiple dependencies, and the trade‑offs of each approach.
This guide explains why Maven archetype project creation often hangs or fails, and provides four practical solutions—including adding internal catalog parameters, configuring VM options, preparing a local archetype‑catalog.xml, and setting an Alibaba mirror—to speed up builds and avoid errors.
Spring Cloud 2021.0.1, the first bug‑fix release of the 2021 line, introduces new routing predicates, configurable gateway handler order, OpenFeign 11.8 updates, Config file matcher fixes, and a comprehensive module version upgrade list, all available via the central Maven repository.
This article provides a detailed step‑by‑step guide to Maven, covering why to use it, its core concepts, installation, creating a first project, repository coordinates, dependency scopes, lifecycle phases, Eclipse integration, advanced dependency features, and build configuration with code examples.
This guide compiles the most useful Maven commands and IDE tips for creating, building, packaging, and deploying multi‑module Java projects, covering project structure, command syntax, advanced combinations, and IntelliJ IDEA integrations.
Even if a project doesn't directly use the Colors library, developers should still check other dependencies for indirect references and ensure all library versions are locked to prevent unexpected behavior and maintain stable builds.
This article explains the concept of Spring Boot starters, how they replace cumbersome Spring MVC setup with automatic dependency import and configuration, details the inner workings of Spring Boot's auto‑configuration mechanism, and guides you through creating custom starters and publishing them as reusable modules.
This article provides a detailed, step‑by‑step guide to Maven, covering why to use it, its core concepts, installation, project structure, pom.xml configuration, common commands, dependency scopes, repository handling, lifecycle phases, Eclipse setup, advanced features, and build customization for Java backend development.
This guide explains how Maven projects can detect, visualize, and resolve hidden dependency conflicts by using tools like mvn dependency:tree, understanding transitivity and the nearest‑wins rule, applying dependencyManagement, scopes, exclusions, optional dependencies, and best practices such as regular analysis and shading to prevent runtime errors.
The article explains how incompatible JAR versions, such as differing Guava releases required by business code and middleware, can be resolved efficiently by using Maven Shade Plugin to relocate packages, offering a lightweight alternative to heavyweight class‑loader isolation solutions like Pandora or SOFAArk.
This article explains the evolution of Go's development workflow from the legacy GOPATH mode to the modern Go Modules system, details version‑specific changes, answers common migration questions, and provides a step‑by‑step tutorial with code examples for creating, testing, and managing Go modules in production projects.
This article reviews the lack of a standard Python project management tool, compares four popular solutions—CookieCutter, PyScaffold, PyBuilder, and Poetry—detailing their installation, generated directory structures, and build commands, while showing how to use Make, tox, and other utilities for testing and packaging.
This article explains Go Modules' major version suffix rules, how the Go tool resolves package paths to module paths using GOPROXY, and the structure and advanced features of the go.mod file, including deprecated warnings and programmatic manipulation.
Spring Cloud 2021 (Jubilee) has been officially released, built on Spring Boot 2.6.x, introducing updated core components, new features like Redis routing, HTTP/2 and gRPC support, and important compatibility notes for Spring Boot and Spring Cloud Alibaba users.
This article explains why Gradle is a superior Java build tool, covering installation methods, the Gradle wrapper, concise dependency management, task and plugin flexibility, mirror and proxy configuration, and the performance advantages over Maven.
The article traces Go’s shift from GOPATH to Go Modules—detailing their history, migration steps, practical commands, and best‑practice tips such as using replace directives, managing go.mod and go.sum, and emphasizing why teams should adopt modules now for reliable dependency handling, security, and developer efficiency.
This article reviews four popular Python project scaffolding and build tools—CookieCutter, PyScaffold, PyBuilder, and Poetry—explaining their installation commands, generated directory layouts, build workflows, and how they differ in complexity and feature coverage.
A recent security breach compromised the popular npm packages coa and rc, injecting ransomware‑capable code that can steal browser passwords, record keystrokes and screenshots, prompting developers to lock specific versions and enable two‑factor authentication to protect their projects.
This article provides a detailed overview of Maven, covering its purpose, core concepts such as coordinates and repositories, the build lifecycle phases, as well as dependency declarations and scopes, as well as plugin configuration, custom bindings, and advanced features like aggregation, inheritance, and profile-based builds.
A compromised UAParser.js npm package spread cryptomining malware and credential theft to an estimated 188,000 computers within four hours, prompting urgent updates and two‑factor authentication for developers relying on this popular JavaScript library.
This article explains Maven's repository types, dependency declarations, version handling, conflict resolution strategies, best practices for early detection, standard directory layout, lifecycle phases, and scope definitions, providing a comprehensive guide for developers to master Maven in Java projects.
Learn how Maven’s dependency resolution can cause jar conflicts, recognize common runtime errors like ClassNotFoundException, and use IDE tools, Maven commands, parent POM management, exclusion and version locking techniques to identify and eliminate conflicting jars in Java backend projects.
Spring Cloud 2020.0.4, a bug‑fix release compatible with Spring Boot 2.4.x and 2.5.x, introduces updated BOM coordinates, new capabilities across Commons, Config, OpenFeign, Netflix, Sleuth, and Kubernetes modules, and provides a comprehensive version table for all upgraded Spring Cloud components.
This comprehensive tutorial explains how to use CocoaPods for iOS and macOS development, covering installation, project initialization, dependency management, podspec creation, private repository setup, version control, caching, and troubleshooting, enabling developers to efficiently manage third‑party libraries and create reusable modules.
This article explains how Gradle 7's Version Catalog feature lets you centralize and share dependency versions, bundles, and plugin declarations across modules and projects, offering type‑safe accessors, version separation, and easy publishing through Maven, with practical code examples and configuration steps.
This article explores common questions about npm and Yarn dependency management, explains the internal installation processes, lockfile roles, version resolution, and compares the two tools while offering practical tips for handling project dependencies in modern JavaScript development.
This article provides a detailed introduction to Maven, covering why to use it, its core concepts, installation steps, project structure, essential commands, dependency management, lifecycle phases, and integration with Eclipse, offering practical code examples and configuration snippets for Java developers.
This article explains Maven’s repository types, dependency declaration, conflict resolution strategies, best‑practice tips, standard directory layout, lifecycle phases, and scope definitions, providing Java developers with the knowledge needed to use Maven confidently in multi‑module projects.
This guide explains how to detect, visualize, and resolve Maven dependency conflicts by using the dependency tree, understanding transitivity and the nearest‑wins rule, managing versions with dependencyManagement, applying scopes, exclusions, and optional flags, and following best practices such as centralizing versions in a parent POM and regularly running analysis tools.
The NetEase News iOS team adopted a three‑layer componentization strategy—foundation, common, and business—standardizing code conventions, Git workflow, and CI‑driven reviews, encapsulating third‑party libraries, managing dependencies via injection and mediators, and distributing binary pods, which reduced the main project to a single file while expanding reusable components to over 250, achieving low coupling and high cohesion.
This article introduces pipenv, explains its concepts, installation methods, virtual environment creation, package management, and commands for handling dependencies, generating Pipfiles, and removing environments, providing a comprehensive tutorial for Python developers in practice.
This article explains why Android developers need Gradle, describes the structure of a default Android project, details Gradle concepts such as projects, tasks, and the wrapper, and walks through dependency configurations, conflict resolution, and the complete build and packaging pipeline for APK generation.
This article explains how to shrink large Spring Boot fat JAR files by separating dependencies into a lib directory and creating small business JARs, covering three optimization levels—including standard dependency separation, merging modules into a shared lib, and handling system‑scope third‑party SDKs—complete with Maven configurations and code examples.
Google’s open‑source security tool, OpenSSF Scorecards, now at version 2.0, automates risk assessment for thousands of projects by providing pass/fail checks, binary‑artifact analysis, dependency verification, and CI/CD token controls, helping organizations identify vulnerable code, malicious contributors, and unsafe dependencies.
This guide explains why Maven's default remote repository can be slow, shows how to configure fast Chinese mirrors such as Alibaba Cloud, NetEase, or Tencent Cloud, and demonstrates how to set these mirrors globally in IntelliJ IDEA so every new project downloads dependencies quickly.
This article explains how to shrink large Spring Boot fat JARs by extracting common dependencies into a shared lib directory and building lightweight business JARs, offering step‑by‑step Maven configurations for four optimization levels that dramatically reduce deployment size and improve update speed for both monolithic and microservice projects.
This article introduces pnpm, a fast and disk‑space‑efficient JavaScript package manager that improves on npm and Yarn, explains its core features such as speed, content‑addressable storage, monorepo support, and strict dependency management, and provides practical usage examples and security considerations.
Spring Boot 2.5 introduces major enhancements such as Java 16 support, Gradle 7 and Jetty 10 compatibility, HTTP/2 over TCP, a revamped datasource initialization mechanism, environment‑variable prefixes, Docker build improvements, layered WARs, actuator endpoint changes, extensive dependency upgrades, and several deprecations, while urging careful migration.
