Awesome GitHub RepositoriesDependency Injection Containers

CodeIgniter is an open-source PHP web framework and application toolkit designed for server-side development. It implements a model-view-controller architecture to separate internal data representations from the user interface. The framework utilizes a front-controller architecture to direct all incoming web requests through a single entry point for URI parsing and request dispatching. It includes a dependency injection container to resolve class dependencies and manage the lifecycle of core system components. The toolkit provides capabilities for routing management, database interactions, a

This project is a comprehensive educational resource and programming course covering C++ language semantics and features from C++03 through C++26. It provides structured tutorials and technical guides focused on modern C++ development. The material offers specialized instruction on template metaprogramming, including the use of type traits and compile-time computations. It features detailed guides on concurrency and parallelism for multi-core execution, as well as a reference for software design applying SOLID principles and RAII. Additionally, it covers build performance optimization to redu

Wire is a compile-time dependency injection framework for Go that generates code to wire application components together. It analyzes function signatures at compile time to build an explicit initialization graph, removing the need for runtime reflection or manual wiring code. The framework operates as a Go code generator and static analysis tool, transforming annotated source code into generated wire files that compile alongside the original project. It connects dependencies by matching function parameters and return types, producing a directed acyclic graph of component dependencies that is

This project is a comprehensive guide to architectural standards and coding patterns for developing maintainable applications within the Laravel framework. It focuses on clean code standards, applying the single responsibility and DRY principles to ensure codebase predictability and consistency. The guide emphasizes decoupling components by moving business logic into service layers and shifting input validation into dedicated request classes to keep controllers lean. It advocates for the use of a service container and dependency injection to reduce class coupling and improve testability. The

Doctrine ORM is a PHP object-relational mapper that connects application objects to relational database tables. It uses the data mapper and identity map patterns to decouple the in-memory object model from the database schema, allowing developers to manage data persistence without writing manual SQL. The project features a dedicated object-oriented query language and programmatic builder for retrieving data based on entities rather than tables. It implements a unit-of-work system to track object changes during a request and synchronize them via atomic transactions. The capability surface inc

Kanboard एक सेल्फ-होस्टेड Kanban प्रोजेक्ट मैनेजमेंट टूल और उत्पादकता सूट है जिसे सॉफ्टवेयर कार्यों को ट्रैक करने और टीम सहयोग के लिए डिज़ाइन किया गया है। यह बोर्ड, कॉलम और कार्ड के उपयोग के माध्यम से वर्कफ़्लो को प्रबंधित करने के लिए एक दृश्य प्रणाली प्रदान करता है। प्रोजेक्ट में एक एक्स्टेंसिबल प्लगइन फ्रेमवर्क और प्रोग्रामेटिक कार्य और प्रोजेक्ट प्रशासन के लिए एक व्यापक API शामिल है। इसमें LDAP एकीकरण के माध्यम से विशेष पहचान प्रबंधन शामिल है, जो निर्देशिका सर्वर से उपयोगकर्ता खातों और समूह अनुमतियों के सिंक्रनाइज़ेशन की अनुमति देता है। सिस्टम इवेंट-ड्रिवन वर्कफ़्लो ऑटोमेशन, बर्न-डाउन चार्ट और साइकिल टाइम मापन जैसे विस्तृत प्रोजेक्ट एनालिटिक्स, और दानेदार भूमिका-आधारित एक्सेस कंट्रोल सहित क्षमताओं की एक विस्तृत श्रृंखला को कवर करता है। यह एकीकृत समय ट्रैकिंग, सबटास्क विघटन, और टू-फैक्टर ऑथेंटिकेशन और रिवर्स प्रॉक्सी सपोर्ट सहित मल्टी-मेथड प्रमाणीकरण का भी समर्थन करता है। एप्लिकेशन निरंतर डेटा स्टोरेज के लिए MySQL और PostgreSQL के साथ संगत है और इसे Docker Compose का उपयोग करके तैनात किया जा सकता है।

This project is a collection of software design patterns implemented in Go, serving as a technical reference and a set of practical programming examples. It maps theoretical architectural patterns to concrete code to demonstrate structural, creational, and behavioral coding techniques. The repository provides implementations for creational patterns focused on object instantiation and blueprint management, structural patterns for organizing object compositions, and behavioral patterns that manage object interactions and responsibilities. The content covers broad capability areas including in

100 Go Mistakes is a reference book and code review companion that catalogues frequent Go programming anti-patterns and provides corrected implementations for each one. It covers a wide range of common pitfalls, from range loop variable capture and interface nil handling to error wrapping and map iteration randomization, helping developers recognize and avoid these issues in their own code. The project distinguishes itself by offering a structured, example-driven approach to learning idiomatic Go. It covers core design decisions such as when to use pointer versus value receivers, how to apply

Clean Architecture template for Golang services

Fx is a dependency injection framework and application lifecycle manager for Go. It functions as a component model container that automates the instantiation and connection of components by analyzing constructor parameters and return values to resolve complex dependency graphs. The framework distinguishes itself through module-based component bundling, which encapsulates related constructors into reusable units to manage visibility and logic. It provides advanced resolution capabilities, including mapping concrete types to interfaces for decoupling, resolving dependency ambiguities via unique

Hyperf is a high-performance PHP coroutine framework designed for building microservices and middleware. It utilizes non-blocking coroutines to handle high concurrency and low-latency request processing, providing a foundation for scalable distributed systems. The framework is distinguished by an aspect-oriented programming based dependency injector that enables pluggable components and meta-programming. It includes a coroutine-optimized object-relational mapper with integrated model caching and an orchestration toolkit for microservice governance, featuring service discovery, circuit breaker

FastStream is an asynchronous Python framework designed for building event-driven microservices. It provides a unified abstraction layer for interacting with various message brokers, enabling developers to manage event production and consumption through a consistent interface while maintaining access to native provider-specific features. The framework centers on a decorator-based routing model that binds application logic directly to broker topics, supported by a built-in dependency injection container that resolves resources at runtime. The framework distinguishes itself through its deep int

This is a dependency injection framework and inversion of control container for Python. It decouples object creation from business logic by managing how services and their dependencies are assembled, delivered, and linked within an application. The framework is distinguished by its ability to perform automated component wiring, using import hooks and decorators to inject dependencies into functions and classes across different modules. It supports non-blocking flows through an asynchronous dependency resolver and manages the initialization and shutdown sequences of shared external resources a

ZIO is a functional effect system for the JVM that models asynchronous and concurrent programs as pure, composable values with typed error handling and dependency injection. Its core identity is built on fiber-based concurrency, where lightweight, non-blocking fibers execute millions of concurrent tasks with structured lifecycle management, and a dual-channel error model that separates expected business failures from unexpected system defects at compile time. The system provides effect-typed dependency injection through a layer-based dependency graph, pull-based reactive stream processing with

godropbox is a backend development framework and service blueprint for building consistent server applications and microservices in Go. It provides a collection of shared libraries and patterns to standardize the development process across multiple projects. The project includes a dependency injection library that decouples business logic from implementations through interface-based service contracts. It also provides a suite of tooling for compiling and deploying Go applications as self-contained static binaries on Linux. The framework covers enterprise application tooling, including shared

यह प्रोजेक्ट Go प्रोग्रामिंग भाषा का उपयोग करके प्रोडक्शन सर्वर्स, हाई-परफॉरमेंस बैकएंड्स, Kubernetes माइक्रोसर्विसेज और AI पाइपलाइन्स को बूटस्ट्रैप करने के लिए स्ट्रक्चरल टेम्पलेट्स और फ्रेमवर्क्स का एक सेट प्रदान करता है। यह इंटीग्रेटेड राउटिंग और मिडलवेयर के साथ हाई-थ्रूपुट इंफ्रास्ट्रक्चर और स्केलेबल प्रोडक्शन सर्वर्स बनाने के लिए एक आधारभूत आर्किटेक्चर के रूप में कार्य करता है। इस फ्रेमवर्क में रिट्रीवल-ऑगमेंटेड जनरेशन सिस्टम विकसित करने के लिए एक विशेष इंफ्रास्ट्रक्चर शामिल है, जो स्थानीय मॉडल इन्फरेंस और सुरक्षित डेटा संप्रभुता पर जोर देता है। यह कंटेनराइज्ड डिप्लॉयमेंट्स के लिए एक समर्पित माइक्रोसर्विस टेम्पलेट भी प्रदान करता है, जो रिसोर्स कोटा और सर्विस लाइफसाइकिल मैनेजमेंट पर केंद्रित है। यह प्रोजेक्ट सिस्टम हेल्थ की निगरानी के लिए ऑब्जर्वेबिलिटी इंस्ट्रूमेंटेशन, इंटरफेस-आधारित डिपेंडेंसी इंजेक्शन, और रिलेशनल डेटा के लिए माइग्रेशन-आधारित स्कीमा मैनेजमेंट सहित व्यापक क्षमता क्षेत्रों को कवर करता है। यह एसिंक्रोनस कार्यों को प्रबंधित करने के लिए चैनल-आधारित कॉनकरेंसी और CPU व मेमोरी प्रोफाइलिंग के माध्यम से रिसोर्स उपयोग ऑप्टिमाइज़ेशन को भी शामिल करता है।

This is a Go library providing a framework for managing repetitive task execution and implementing exponential backoff strategies. It serves as a concurrency tool designed to prevent system overload during failures by retrying operations with increasing delays. The project implements a retry strategy framework that manages attempt limits and timeouts during unstable network or system calls. It specifically provides an implementation of the exponential backoff algorithm to handle failing operations. The library covers reliability patterns for mitigating transient failures and service outages,

CTMediator is a dynamic service locator and modular architecture framework for iOS. It functions as a dependency decoupler that allows large projects to be split into smaller, independent subprojects and targets to improve organization and reduce build times. The framework enables communication between these isolated modules using a target-action pattern. It utilizes dynamic runtime lookups to dispatch requests and route actions to specific modules without requiring a manual service registration process during startup. The system manages data exchange and project decomposition through protoc

यह प्रोजेक्ट एक PHP इंटरफेस लाइब्रेरी है जो एक कंपोनेंट इंटरऑपरेबिलिटी लेयर प्रदान करती है। इसमें फ्रेमवर्क-अज्ञेयवादी कॉन्ट्रैक्ट्स और स्टैंडर्डाइज्ड डेफिनिशन का एक सेट शामिल है जो विभिन्न लाइब्रेरीज़ को एक सुसंगत कॉन्ट्रैक्ट के माध्यम से एक साथ काम करने में सक्षम बनाता है। यह लाइब्रेरी न्यूनतम शेयर्ड इंटरफेस और API डेफिनिशन प्रदान करने पर केंद्रित है, जिससे सॉफ्टवेयर कंपोनेंट्स को अंतर्निहित फ्रेमवर्क की परवाह किए बिना विभिन्न PHP प्रोजेक्ट्स में उपयोग किया जा सके। यह दृष्टिकोण एप्लिकेशन लॉजिक को कंक्रीट फ्रेमवर्क इम्प्लीमेंटेशन से अलग करता है। यह प्रोजेक्ट विशेष रूप से सर्विस कंटेनर एब्स्ट्रैक्शन और डिपेंडेंसी इंजेक्शन स्टैंडर्डाइजेशन को कवर करता है। सर्विस कंटेनर्स को एक्सेस करने के लिए सामान्य इंटरफेस को परिभाषित करके, यह विभिन्न कंटेनर इम्प्लीमेंटेशन के बीच इंटरऑपरेबिलिटी सुनिश्चित करता है और कंपोनेंट्स को विभिन्न एनवायरनमेंट में डिपेंडेंसीज़ प्राप्त करने की अनुमति देता है।

This project is a comprehensive Python style guide and technical reference designed to promote the creation of clean, maintainable, and idiomatic code. It provides a set of opinionated guidelines and architectural patterns focusing on functional and declarative programming to reduce complexity and improve overall code quality. The guide establishes specific standards for naming conventions, module organization, and project layout. It emphasizes reducing object coupling by favoring modules and functions over deep class hierarchies and offers technical standards for writing docstrings and marku