Awesome GitHub RepositoriesClass-Based Architecture

This project is a curated reference guide and cheatsheet for modern JavaScript development. It provides a collection of syntax and patterns covering ECMAScript standards, specifically focusing on contemporary language features from ES6 and later. The resource offers specialized guides on asynchronous JavaScript, functional programming patterns, and object-oriented design. It details the use of promises and async/await syntax for non-blocking operations, as well as the application of map, filter, and reduce for data transformation. The guide covers a broad range of language fundamentals, incl

DesignPatternsPHP is a reference collection of sample code implementations for common software design patterns using PHP 8.x. It provides a set of examples for implementing creational, structural, and behavioral patterns to organize object-oriented design. The project includes reference implementations for creational patterns that decouple systems from object instantiation, structural patterns that define how classes organize into complex components, and behavioral patterns that manage algorithms and responsibilities between objects.

Carbon is a date and time manipulation library for PHP that extends the native DateTime class. It provides a set of tools for calculating, formatting, and comparing dates and times using a simplified, human-readable syntax. The library utilizes a fluent interface and static factory methods to allow for chained method calls and intuitive object instantiation. It supports both mutable and immutable state options to manage how date objects are modified and returned. The toolset covers temporal data management, including time zone handling and localization-based formatting to convert date compon

micrograd is a scalar autograd engine and minimal neural network library. It implements a system for reverse-mode automatic differentiation over a dynamic graph of scalar operations to calculate gradients. The project includes a computation graph visualizer that generates representations of data flow and gradient propagation. It provides a set of tools for constructing and training multi-layer perceptrons using an API modeled after PyTorch. The library covers the fundamentals of backpropagation and neural network construction, specifically for binary classification tasks. This includes the i

LanguageTool is a multilingual grammar and style checking engine designed to detect spelling, grammar, and writing errors across multiple languages. It provides automated proofreading capabilities that can be deployed as a self-hosted server or executed as a standalone local desktop application. The project distinguishes itself through a flexible rule development framework, allowing linguistic patterns to be defined via XML or implemented as custom Java classes. It utilizes n-gram frequency modeling for confused word detection and supports neural word embeddings to improve disambiguation betw

MJRefresh is a scroll view interaction library and a set of reusable UI components for implementing pull-to-refresh and infinite scrolling behaviors in mobile user interfaces. It provides customizable refresh indicators and controllers that manage reload callbacks and loading states within scrollable containers. The library allows for the replacement of standard loading indicators with custom images, GIF sequences, and status labels to match specific visual branding. It includes a global configuration store to handle dynamic UI localization and the translation of refresh content across an app

Stimulus is a JavaScript behavior framework and client-side logic layer used to add interactive behavior to server-rendered HTML. It functions as a system of DOM component controllers that organize JavaScript logic into classes, allowing developers to enhance server-delivered markup without replacing the rendering process with a client-side framework. The framework uses data attributes to bind JavaScript classes to HTML elements and map DOM events to specific methods through document-level event delegation. It employs a lifecycle manager based on mutation observers to automatically instantiat

This project is a reference collection of statistical learning algorithms built from scratch using NumPy for linear algebra and matrix operations. It serves as an educational resource for studying the mathematical foundations and inner workings of machine learning models through manual implementations. The codebase provides hand-coded implementations of both supervised and unsupervised learning. This includes classification and regression models such as support vector machines, decision trees, and Naive Bayes, as well as data clustering and pattern discovery methods like k-means and hierarchi

This is a comprehensive tutorial for learning TypeScript, designed for JavaScript programmers who want to understand the language's type system and modern features. The resource covers TypeScript's core identity, including its structural type compatibility, compile-time type erasure, declaration file merging, and the discriminated union pattern for precise type narrowing. The tutorial distinguishes itself by providing a progressive learning path from basic JavaScript concepts to advanced TypeScript patterns. It covers generic type parameter constraints, tuple types with fixed-length positions

Tkinter-Designer is a tool for converting Figma design files into executable Python source code and visual assets. It automates the transformation of visual design layouts into functional Tkinter source code to facilitate the creation of desktop application prototypes. The project converts Figma design URLs and API tokens into functional interfaces, processing individual design frames as independent views. This enables the generation of multi-screen applications with navigation logic to move between different layouts. The generated output uses a class-based architecture to organize screens,

This project is a structured learning curriculum and technical reference for mastering deep learning with TensorFlow. It provides a comprehensive guide for building, training, and deploying neural networks, combining theoretical fundamentals with practical implementation examples. The repository distinguishes itself by covering the end-to-end machine learning workflow, from low-level tensor mathematics and linear algebra to the creation of complex model architectures. It includes specific guidance on developing data pipelines for diverse data types, such as images, text, and time-series seque

Sonnet is a modular machine learning framework and TensorFlow neural network library designed for building composable deep learning architectures. It functions as a model orchestrator that manages parameters, state serialization, and graph exports during the training process. The framework provides a distributed training system to synchronize gradients and spread workloads across multiple GPUs or hardware devices. It enables the design of reusable research components through high-level abstractions and subclassing. The library covers neural network architecture design through sequential laye

RSS-Bridge is a self-hosted feed generator and proxy that transforms website content from sources without native feeds into standardized Atom, RSS, or JSON web feeds. It functions as a web scraping system that extracts data from pages using CSS selectors and XPath to create structured data streams for feed readers. The project is designed for extensibility, allowing for the development of custom bridges to fetch and parse data from new target websites. It includes capabilities for feed aggregation and filtering, enabling the merging of multiple data sources into a single feed and the removal

JUnit 4 is a unit testing framework for Java that provides a structured approach to writing and running automated tests. At its core, it uses annotation-based test discovery to automatically identify test methods, and a pluggable runner architecture that controls how test classes are discovered, instantiated, and executed. The framework builds test execution around a chain of Statement objects, each wrapping the next to layer behaviors such as timeouts and retries, and uses Java reflection to dynamically invoke test methods and access private fields for setup and teardown operations. The fram

Graphene is a library and framework for building type-safe GraphQL APIs and schemas using Python objects and resolvers. It provides a system for mapping internal data models to typed GraphQL schemas, enabling the creation of servers that process queries and execute resolvers to return structured data. The project includes a full implementation of the Relay specification, providing standardized patterns for global object identification and cursor-based pagination. It utilizes a class-based approach to schema definition and supports interface-based type inheritance. The framework covers a broa

Type-graphql is a framework for building GraphQL servers that uses TypeScript classes as the single source of truth for schema definitions and types. It provides a schema generator and a resolver framework that allows developers to define queries and mutations using class-based controllers and decorators. The project focuses on a schema-first approach where TypeScript classes and metadata reflection are used to automatically derive GraphQL schemas. It incorporates a dependency injection container to manage the instantiation and lifecycle of resolver classes. The system includes a middleware

Type-graphql is a toolkit and framework for creating type-safe GraphQL APIs. It functions as a schema generator and resolver library that uses TypeScript classes and decorators as the primary source of truth for data structures and query logic. The project enables the definition of GraphQL schemas and resolvers through typed classes rather than manual schema definition language. This approach ensures that TypeScript types automatically align with the GraphQL schema to prevent runtime errors. The framework provides capabilities for API implementation, including input data validation and acces

Wren is a bytecode-compiled, class-based scripting language designed as an embeddable programming language. It provides a lightweight runtime and interface for executing dynamic scripts directly within host software applications. The engine utilizes a single-pass compiler to transform source code into compact bytecode and a virtual machine to process those instructions. It supports concurrent task execution through a system of lightweight fibers and coroutines. The language implements a class-based object model with dynamic message dispatch for organizing code into reusable components. It al

ElastAlert is an alerting framework and query monitor for Elasticsearch. It functions as a real-time log monitoring tool and event notification engine that scans indices for specific patterns to trigger automated alerts when predefined rules are matched. The system distinguishes itself through specialized detection logic, including event spike detection, event frequency monitoring, field change tracking, and the identification of new terms within data fields. It handles notification noise via stateful alert suppression to prevent redundant messages and provides time-windowed aggregation to gr

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