Awesome List Updates on Apr 17 - Apr 23, 2023

55 awesome lists updated this week.

🏠 Home · 🔍 Search · 🔥 Feed · 📮 Subscribe · ❤️ Sponsor

1. ALL About RSS

FreshRSS / Outline Processor Markup Language

• https://feeds.flossboxin.org.in by vdbhb59 (user:demo2023 passwd:demodemo)

2. Awesome Postgres

Contents / CLI

• atlas (⭐7k) - Atlas is a tool for managing and migrating database schemas using modern DevOps principles.

3. Awesome Gnome

System and Customization

• GDM Settings - A settings app for GDM (GNOME's Login Screen a.k.a GNOME Display Manager).

4. Awesome List

Gaming

• GameMaker (⭐381) - Game engine.

Learn

• Hackathon (⭐166) - Running fun and productive hackathons.

5. Awesome Social Enterprise

Fellowships / Articles

• Radical Partners - Miami-based social impact accelerator.

• Seaworthy Collective - Miami-based BlueTech entrepreneur support organization.

Institutions 🏫 / Articles

• Pepperdine's MA in Social Entrepreneurship and Change

6. Amas

Ask these people anything!

• Angelo Pirola (⭐0) - Microsoft (.NET) Backend Web Developer, GitHub contributor and based in Italy.

7. Awesome Billing

Fraud / Cards

• Reproducible Machine Learning for Credit Card Fraud detection - A practical handbook on how to identify patterns in transactions.

8. Awesome Zsh Plugins

Plugins / superconsole - Windows-only

• aws-vault (⭐90) - Plugin for aws-vault (⭐8.8k). Includes tab completions.

• fzf-tab (⭐4k) - Replace ZSH's default completion selection menu with fzf (⭐72k).

• pnpm (leizhenpeng) (⭐5) - Adds useful aliases for common pnpm commands.

• todotxt (⭐0) - Adds aliases for todo.sh (⭐23).

Themes / superconsole - Windows-only

• ai-hayasaka (⭐0) - Minimalist theme with git status, ruby env and python virtualenv decorators.

9. Awesome Graphql

Tools - Miscellaneous / React

• DronaHQ - Build internal tools, dashboards, admin panel on top of GraphQL data in minutes

10. Awesome Vue

Resources / Community

• VueJS Translations Ukraine - Telegram Group (Ukraine)

Projects Using Vue.js / Open Source

• vue-paho-mqtt (⭐26) - Easy-to-use Paho MQTT client library for Vue 3 with centralized subscription management, type support, and built-in optional alert notification library.

• VueFinder File Library (⭐350) - Web File Manager Library.

Components & Libraries / UI Components

• vue-maplibre-gl (⭐107) - Vue 3.x wrapper around Maplibre GL JS library written in TS. Including style switch and frame rate control.

• Everright-formEditor (⭐489) - A visual drag-and-drop low-code form editor

11. Awesome Iam

Competitive Analysis / GDPR

• Best-of Digital Identity (⭐139) - Ranking, popularity and activity status of open-source digital identity projects.

12. Awesome Tmux

Tools and session management

• twm (⭐41) A highly configurable workspace manager that is easy to extend with shell scripts, written in Rust

13. Awesome Cli Apps

Files and Directories / File Managers

• clifm (⭐1.4k) - The command line file manager.

14. Awesome Falsehood

Software Engineering

• The weird world of Windows file paths - “On any Unix-derived system, a path is an admirably simple thing: if it starts with a /, it's a path. Not so on Windows.”

15. Awesome Privacy

ChatGPT

• LocalAI (⭐34k) - Self-hosted, community-driven simple local OpenAI-compatible API written in go. Can be used as a drop-in replacement for OpenAI, running on CPU with consumer-grade hardware.

16. Awesome Selfhosted

Software / Archiving and Digital Preservation (DP)

• Webarchive (⭐146) - Lightweight self-hosted wayback machine that creates HTML and PDF files from your bookmarks. BSD-3-Clause Go

17. Awesome Ruby

Database Tools

• Online Migrations (⭐694) - Catch unsafe PostgreSQL migrations in development and run them easier in production.

Feature Flippers and A/B Testing

• Unleash (⭐60) - Ruby client for Unleash, a powerful feature toggle system that gives you a great overview over all feature toggles across all your applications and services.

Machine Learning

• ruby-openai (⭐3.1k) - OpenAI API + Ruby!

PDF

• Grim (⭐227) - Extract PDF pages as images and text. A simple Ruby API to ghostscript, imagemagick, and pdftotext.

18. Awesome React Components

Chart

• echarts for react (⭐4.8k) - Wrapper around beautiful Apache Echarts

19. Awesome Audit Algorithms

Papers / 2023

• Confidential-PROFITT: Confidential PROof of FaIr Training of Trees - (ICLR) Proposes fair decision tree learning algorithms along with zero-knowledge proof protocols to obtain a proof of fairness on the audited server.

20. Awesome Terraform

Tools / Community providers

• terraform-repl (⭐132) - A terraform console wrapper for a better interactive console experience.

21. Awesome Osint

Real-Time Search, Social Media Search, and General Social Media Tools

• Epieos - Search for social accounts with e-mail and phone

22. Awesome Polars

Tutorials & workshops / Miscellaneous

• How to display Polars dataframes with itables - A tutorial that explains how to display Polars dataframes with itables by @mwouts.

Blog posts / Miscellaneous

• The fastest way to read a CSV file in Python - A blog post that compares different ways (including Polars, pyarrow and C) to read a CSV file with Python by Finn Andersen.

Talks and videos / Miscellaneous

• An opinionated introduction to Polars - Great Polars introduction slides from @krlng at PyCon 2023.

23. Awesome Vite

Framework-agnostic Plugins / Integrations

• vite-plugin-auto-mpa-html (⭐9) - A file directory-based automated multi-page build plugin that supports HTML templates using EJS.

Vue / Transformers

• vite-plugin-vue-css-modules (⭐20) - Implicit usage of CSS Modules for template and script SFC tags with static replacement.

24. Urban and Regional Planning Resources

Planning Data Specifications / Transportation

• OpenSidewalks (⭐52) - A data specification for routable pedestrian networks and describing and sharing pedestrian network and pedestrian network-adjacent data.

25. Machine Learning with Ruby

Machine Learning Libraries / Vector search

• milvus (⭐29) — Ruby client for Milvus Vector DB.

• pinecone (⭐65) — Ruby client for Pinecone Vector DB.

• qdrant-ruby (⭐48) — Ruby wrapper for the Qdrant vector search database API.

• weaviate-ruby (⭐55) — Ruby wrapper for the Weaviate vector search database API.

26. Awesome Datascience

MOOC's

• Programming with Julia

27. Awesome Embedded Rust

HAL implementation crates / Espressif

• esp-idf-hal
  • An embedded-hal implementation for Rust on ESP32 microcontrollers and ESP-IDF

• esp-hal
  • A no_std Hardware Abstraction Layers for ESP32 microcontrollers

Firmware projects / WIP

• μLA (⭐860): Micro Logic Analyzer for RP2040

28. Awesome Pascal

General Libraries

• mORMot (⭐808). [Delphi] [FPC] Client-Server ORM/ODM SOA MVC framework for Delphi 6 and higher, or FPC 2.7. Direct SQL/NoSQL database access, ORM/ODM over objects, RESTful ORM and SOA services via interfaces over high performance HTTP server, MVC/MVVM web sites, testing including mocks and stubs, logging, cryptography, compression, command line parser, threading, service/daemon support; huge documentation.

• minilib (⭐77). [Delphi] [FPC] cross platform library, Socket wrapper (include SSL and TLS), and Database connection (SQLite, PostgreSQL, FirebirdSQL, MariaDB), XML reader and writer, ComPort (COM1, COM2 etc).

• Fido Library (⭐47). [Delphi] The Fido library has been created to make the life of a Delphi developer easier by following the "describe behavior instead of coding it, whenever is possible" design principle. Below is a list of the most important core features: Mappers, JSON marshalling and unmarshalling, Virtual database features, Virtual Api clients, Virtual Api servers, Websockets, Consul and Fabio support, Boxes, Events driven architecture, Functional programming, Currying, Caching, Channels

Audio

• FMXAudio (⭐60). [Delphi] Audio player component based BASS for FMX (Windows, Android)

Graphic

• Blen2d4Delphi (⭐19). [Delphi] Blend2D is a high performance 2D vector graphics engine written in C++ and released under the Zlib license. The engine utilizes a built-in JIT compiler to generate optimized pipelines at runtime and is capable of using multiple threads to boost the performance beyond the possibilities of single-threaded rendering.

• Delphi wrapper for libdmtx (⭐8). [Delphi] Libdmtx is a software library that enables programs to read and write Data Matrix barcodes of the modern ECC200 variety. The library runs natively on several platforms and can be accessed by multiple languages using the libdmtx language wrappers

Serial port

• ComPortDriver (⭐58). '[Delphi]' Delphi/C++ Builder serial communications component. Tested up to 921600 baud. Supports sending break as well. Works asynchronously by polling via timer (interval configurable). Demo included.

• ComPort Library (⭐92). [Delphi] COM Port Library for Delphi (fork from SourceForge) . The ComPort Library contains code to access COM Ports. Originally, the COM port was the name of the serial port interface of IBM-PC compatible computers. While nowadays COM ports get less important for communication in favor for USB access, it is still in use as virtual ports, especially as simple communication protocol for maker boards.

• Usb serial controller for Android (⭐1.9k) [Delphi] Usb serial controller for Android

Event bus

• PubSub Chimera. [Delphi] Open Source (MIT License) library for Delphi which provides a fast and cross platform PubSub and Message Queue implementation under a license that doesn't suck.

• Delphi Event Bus (⭐486) (for short DEB). [Delphi] Event Bus framework for Delphi.

• DelphiEventBus (⭐40). [Delphi] Yet another Event Bus framework for Delphi, with annotations and rich event filtering.

• VSoft.Messaging (⭐56). [Delphi] Libary that provides an internal synchronous/asynchronous publish/subscribe messaging system for Delphi applications.

• iPub Messaging (⭐58). [Delphi] Thread safe, asynchronous and simplistic messaging system for communication between classes / layers in delphi created by the iPub team.

• NX-Horizon (⭐123). [Delphi] Event Bus for Delphi. Implements the publish/subscribe pattern, supports sync/async types of event delivery, simple in both implementation and usage, fast, full thread safety.

Other GUI

• FMXTrayIcon (⭐28). [Delphi] TrayIcon for FMX Windows

• Form Designer component for Delphi (VCL) (⭐75). [Delphi] Form Designer (TFormDesigner) can be used to design and modify Delphi (VCL) forms at runtime. The behavior and appearance is similar to that of Delphi IDE.

Database

• SQLite for Delphi and FreePascal/Lazarus (⭐128). [Delphi] [FPC] Complete SQLite3 API translation for Delphi and FreePascal/Lazarus, as well as a simple Unicode-enabled object wrapper to simplify the use of this database engine.

Machine Learning

• Keras4Delphi (⭐55). [Delphi] High-level neural networks API, written in Pascal with Python Binding

• Marvin.IA (⭐47). [Delphi] Machine learning collection of object-oriented Pascal primitives (only interfaces and classes).

• TensorFlow.Delphi (⭐79). [Delphi] TensorFlow library binding for Delphi. It aims to implement the complete Tensorflow API in Delphi which allows Pascal developers to develop, train and deploy Machine Learning models with the Pascal Delphi

Memory managers

• Delphi64RTL (⭐37). [Delphi] Object Pascal wrappers from Intel Integrated Performance Primitives and Intel Threading Building Blocks royalty-free packages. Includes lock-free scalable allocator, simd enabled rtl subset routines (memory fill, copy, compare) and accelerated zlib compression // Uses Intel DLLs for accelerated low-level memory manipulations

Other non-visual

• TDiff (⭐58). [Delphi] [FPC] Text compare component for Delphi and Free Pascal. Dramatically simplify programming tasks that require calculations of 'shortest path' or 'longest common sequence' as typically required in file compare utilities.

• GraphQL for Delphi (⭐71). [Delphi] Simple implementation for GraphQL, a query language for APIs created by Facebook. GraphQL is a query language for your API and a server-side runtime for executing queries using a type system you define for your data. GraphQL isn't tied to any specific database or storage engine and is instead backed by your existing code and data.

• GraphQL Constructor (⭐10). [Delphi] GraphQL Constructor (constructor only)

OS

• SVGShellExtensions (⭐168). [Delphi] Shell extensions for SVG files (Preview Panel, Thumbnail Icon, SVG Editor)

• MarkdownShellExtensions (⭐88). [Delphi] Markdown file Shell Extensions for Windows Explorer plus a Markdown file editor with instant preview

Report generating

• Kryvich's Delphi Reporter (⭐18). [Delphi] Simple but powerful reporting tool for Embarcadero's (CodeGear, Borland) Delphi. It generates reports in TXT, RTF, HTML and XML formats based on custom templates and information from any TDataSet compatible data sets.

Other

• James - The Delphi Project Manager (⭐51). [Delphi] It makes your life easier while switching from one project to another. If you see yourself manually installing components and updating Delphi settings every time you have to switch from one project to another, James may help you.

29. Awesome Directus

Extensions / Community

• Generate Types (⭐245) - Adds a module for generating typescript types for a Directus JS-SDK connected to that Directus database. Also can generate Python or OpenAPI types.

• Computed Interface (⭐219) - Perform computed value based on other fields.

30. Awesome Decentralized

Applications

• Nostr (⭐11k) - A decentralized social network with a chance of working. A simple, open protocol that enables a truly censorship-resistant and global social network (https://nostr.com/)

31. Tools

Placeholder

• placehold.it

32. Awesome Go

Continuous Integration

• go-test-coverage (⭐157) - Tool and GitHub action which reports issues when test coverage is below set threshold.

Caches

• imcache (⭐125) - A generic in-memory cache Go library. It supports expiration, sliding expiration, max entries limit, eviction callbacks and sharding.

• theine (⭐335) - High performance, near optimal in-memory cache with proactive TTL expiration and generics.

Images

• color-extractor (⭐99) - Dominant color extractor with no external dependencies.

Logging

• log (⭐3) - A simple logging framework out of the box.

Other Software / Libraries for creating HTTP middlewares

• zs - an extremely minimal static site generator.

33. Awesome Plotters

Inspiration, Instruction, and Research / Fonts

• CuriousMarc: Refilling or Replacing Vintage HP Plotter Pens - Video showing how to open, clean, and refill vintage HP plotter pens.

Manuals, Ephemera, Papers, and Patents / Ephemera

• Hewlett-Packard Journal Volume 32 Number 10 - Multiple articles about the development of the HP Model 7580A plotter.

34. Awesome Web Archiving

Tools & Software / Utilities

• warcdedupe - WARC deduplication tool (and WARC library) written in Rust. (In Development)

35. Static Analysis

Programming Languages / Other

• ruff — Fast Python linter, written in Rust. 10-100x faster than existing linters. Compatible with Python 3.10. Supports file watcher.

Multiple languages / Other

• Goodcheck — Regexp based customizable linter.

36. Awesome Zig

Audio

• orhun/linuxwave (⭐589) - Generate music from the entropy of Linux.

37. Awesome Esolangs

Languages

• Electra (⭐97) - Code like an electrician.

38. Awesome React

React General Resources

• React Community

React Tutorials

• React Official Tutorial

• React Interview Questions & Answers (⭐42k)

• Design patterns and Component patterns for building powerful Web Apps

• A simple, scalable, and powerful architecture for building production ready React applications (⭐32k)

• The Fullstack Tutorial for GraphQL (⭐8.7k)

React Frameworks

• next (⭐133k) - The React Framework

• gatsby (⭐56k) - Build modern websites with React

• react-admin (⭐26k) - A frontend Framework for building B2B applications

• refine (⭐32k) - Build your React-based CRUD applications, without constraints

React Component Libraries

• ant-design (⭐95k) - An enterprise-class UI design language and React UI library

• framework7 (⭐18k) - Full featured HTML framework for building iOS & Android apps

• ariakit (⭐8.3k) - Toolkit for building accessible web apps with React

React Styling

• styled-components (⭐41k) - Visual primitives for the component age

• emotion (⭐18k) - CSS-in-JS library designed for high performance style composition

• vanilla-extract (⭐10k) - Zero-runtime Stylesheets-in-TypeScript

React Routing

• react-router (⭐55k) - Declarative routing for React

• wouter (⭐7.3k) - A minimalist-friendly routing

• tanstack-router (⭐11k) - Type-safe router with built-in caching & URL state management

React Libraries

• preact (⭐38k) - Fast React alternative with the same modern API

• floating-ui (⭐31k) - Toolkit to create floating elements

• loadable-components (⭐7.8k) - The recommended Code Splitting library for React

• react-uploady (⭐1.2k) - Modern file-upload components & hooks for React

• downshift (⭐12k) - React autocomplete, combobox or select dropdown components

React Testing

• jest (⭐45k) - Delightful JavaScript Testing

• react-testing-library (⭐19k) - Simple and complete React DOM testing utilities

• cypress (⭐49k) - Fast, easy and reliable testing for anything that runs in a browser

React Awesome Components

• Awesome React Components (⭐45k)

• react-big-calendar (⭐8.4k) - Calendar component

• react-datepicker (⭐8.3k) - A simple and reusable datepicker component for React

• react-qrcode (⭐4.1k) - QR component for use with React

• react-icons (⭐12k) - SVG React icons of popular icon packs

• react-complex-tree (⭐1.2k) - Unopinionated Accessible Tree

• react-insta-stories (⭐1.4k) - A React component for Instagram like stories

• swiper (⭐41k) - Most modern mobile touch slider

• keen-slider (⭐4.9k) - The Touch slider carousel

• cookie-consent-banner (⭐167) – The lightweight and flexible Cookie Consent Banner

• heart-switch (⭐449) - A heart-shaped toggle switch component for React

• kbar (⭐5.1k) - Fast, portable, and extensible cmd+k interface for your site

• tagify (⭐3.8k) - Lightweight, efficient Tags input component

React Components Sandboxes

• storybook (⭐87k) - Storybook is a frontend workshop for building UI components and pages in isolation

• react-styleguidist (⭐11k) - Isolated React component development environment with a living style guide

• react-cosmos (⭐8.5k) - Dev tool for creating reusable React components

React Forms

• react-hook-form (⭐43k) - React Hooks for form state management and validation

• vest (⭐2.6k) - Declarative validations framework

React Tables and Grids

• react-grid-layout (⭐21k) - A draggable and resizable grid layout with responsive breakpoints

• tanstack-table (⭐27k) - Headless UI for building powerful tables & datagrids

• react-data-grid (⭐7.3k) - Feature-rich and customizable data grid React component

React Internationalization

• formatjs (⭐15k) - Internationalize your web apps

• react-i18next (⭐9.6k) - Internationalization for React done right

React Graphics and Animations

• react-spring (⭐29k) - A spring physics based React animation library

• framer-motion (⭐29k) - Open source, production-ready animation and gesture library for React

• auto-animate (⭐13k) - A zero-config, drop-in animation utility that adds smooth transitions

• react-tsparticles (⭐8.3k) - Easily create highly customizable particles effects

• react-parallax-tilt (⭐1k) - Easily apply tilt hover effect on React components

React Integration

• rescript-compiler (⭐7.1k) - A robustly typed language that compiles to efficient and human-readable JavaScript

• react-rails (⭐6.8k) - Integrate React with Rails

• fulcro (⭐1.6k) - A library for development of web applications in clj/cljs

React Real Apps

• mattermost-server (⭐33k) - An open source platform for secure collaboration

• kibana (⭐21k) - Your window into the Elastic Stack

• webamp (⭐11k) - Winamp 2 reimplemented for the browser

• overreacted (⭐7.2k) - Personal blog by Dan Abramov

React Native General Resources

• React Native Official Website

• React Native Community

• Expo

39. Awesome V

Command-line

• vzcc (⭐28) - A CLI cross-compiling tool based on Zig CC for V.

Tutorials / Vim

• VOSCA Blog Tutorials - Tutorial category on VOSCA blog.

40. Awesome Ddd

Sample Projects / JavaScript / TypeScript

• Over-engineered ToDo app (⭐1.3k) - Complete working example of using Domain Driven Design (DDD), Hexagonal Architecture, CQRS, Event Sourcing (ES), Event Driven Architecture (EDA), Behaviour Driven Development (BDD) using TypeScript and NestJS generated using the Bitloops Language (BL) (⭐353).

Libraries and Frameworks / JavaScript / TypeScript

• Bitloops Language (BL) (⭐353) - Open-source, 4th-generation, transpiled programming language that helps you write clean code, well-designed systems, and build high-quality software that is testable, auditable and maintainable using DDD and Hexagonal Architecture.

• Node API Boilerplate (⭐3.3k) - NodeJS web API boilerplate for DDD and Clean Architecture applications.

41. Awesome Developer First

Authentication & Identity

• Clerk - Authentication and user management platform for React, React Native, and Next.js.

42. Awesome Mac

Developer Tools / Version Control

• GitFinder - Fast and lightweight Git client for Mac with Finder integration.

Utilities / General Tools

• lo-rain - Create a customizable rain over your desktop and apps, with splash over the dock.

Utilities / Window Management

• Sidebar - The modern Dock replacement for your Mac.

43. Awesome Spark

Packages / Middleware

• Apache Kyuubi (⭐2.2k) - A distributed multi-tenant JDBC server for large-scale data processing and analytics, built on top of Apache Spark.

Resources / Docker Images

• apache/spark - Apache Spark Official Docker images.

44. Awesome Flutter

Navigation / Image Picker

• auto_route (⭐1.7k) - AutoRoute is a declarative routing solution, where everything needed for navigation is automatically generated for you. Milad_Akarie.

45. Awesome Flame

App Releases / Casual

• BBB - Birds, Beasts, Baddies - Android - Four furry and feathery friends jump for joy. Avoid enemies, collect mushrooms, jump as high as you can. By Coconut Island Apps

46. Awesome Orgs

Cloud

• Kong - The cloud connectivity company. Community-driven & enterprise-adopted.

Web

• UnJS - Unified JavaScript tools.

Database

• Supabase - The open source Firebase alternative.

Analytics

• PostHog - Open source product analytics platform.

Other

• Axo - Collection of open source Rust libraries and tools.

• TheAlgorithms - Open source resource for learning data structures & algorithms and their implementation in any programming language.

• Z-Shell - Open source society passionate about Zsh.

47. Awesome Crystal

HTML Builders

• blueprint (⭐63) - Write reusable and testable HTML templates in plain Crystal

• Water (⭐29) - A library for writing HTML in plain Crystal

48. Awesome Sysadmin

Software / Automation

• Apache Ant - Automation build tool, similar to make, a library and command-line tool whose mission is to drive processes described in build files as targets and extension points dependent upon each other. (Source Code (⭐440)) Apache-2.0 Java

• Rake - Build automation tool similar to Make, written in and extensible in Ruby. (Source Code (⭐2.4k)) MIT Ruby

Software / DNS - Servers

• Bind - Versatile, classic, complete name server software. (Source Code) MPL-2.0 C

• CoreDNS - Flexible DNS server. (Source Code (⭐13k)) Apache-2.0 Go

• dnsmasq - Provides network infrastructure for small networks: DNS, DHCP, router advertisement and network boot. (Source Code) GPL-2.0 C

• Knot - High performance authoritative-only DNS server. (Source Code) GPL-3.0 C

• NSD - Authoritative DNS name server developed speed, reliability, stability and security. (Source Code (⭐497)) BSD-3-Clause C

• Unbound - Validating, recursive, and caching DNS resolver. (Source Code (⭐3.6k)) BSD-3-Clause C

• Yadifa - Clean, small, light and RFC-compliant name server implementation developed from scratch by .eu. (Source Code (⭐72)) BSD-3-Clause C

49. Awesome Neovim

Color / Diagnostics

• Mr-LLLLL/interestingwords.nvim (⭐47) - Highlight multiple word same time and navigate word under cursor with scrolling smoothly, display search count in virualtext.

Colorscheme Creation / Diagnostics

• echasnovski/mini.nvim#mini.colors (⭐7.5k) - Module of mini.nvim to tweak and save any color scheme. Also can animate transition and convert between some color spaces.

Bars and Lines / Diagnostics

• luukvbaal/statuscol.nvim (⭐581) - Configurable 'statuscolumn' with builtin segments and click handlers.

Utility / Diagnostics

• sQVe/bufignore.nvim (⭐16) - Unlist hidden buffers matching specified ignore sources.

• hbac.nvim (⭐215) - Automatically close buffers you are not working on.

• ecthelionvi/NeoComposer.nvim (⭐416) - Simplify macro management, enhance productivity, and create harmonious workflows.

Formatting / Diagnostics

• tenxsoydev/tabs-vs-spaces.nvim (⭐24) - Hint and fix deviating indentation.

50. Awesome Integration

Integration Patterns / Enterprise Integration Patterns

• Aggregator - How do we combine the results of individual, but related messages so that they can be processed as a whole?

• Canonical Data Model - How can you minimize dependencies when integrating applications that use different data formats?

• Channel Adapter - How can you connect an application to the messaging system so that it can send and receive messages?

• Channel Purger - How can you keep 'left-over' messages on a channel from disturbing tests or running systems?

• Claim Check - How can we reduce the data volume of message sent across the system without sacrificing information content?

• Command Message - How can messaging be used to invoke a procedure in another application?

• Competing Consumers - How can a messaging client process multiple messages concurrently?

• Composed Message Processor - How can you maintain the overall message flow when processing a message consisting of multiple elements, each of which may require different processing?

• Content Enricher - How do we communicate with another system if the message originator does not have all the required data items available?

• Content Filter - How do you simplify dealing with a large message, when you are interested only in a few data items?

• Content-Based Router - How do we handle a situation where the implementation of a single logical function (e.g., inventory check) is spread across multiple physical systems?

• Control Bus - How can we effectively administer a messaging system that is distributed across multiple platforms and a wide geographic area?

• Correlation Identifier - How does a requestor that has received a reply know which request this is the reply for?

• Datatype Channel - How can the application send a data item such that the receiver will know how to process it?

• Dead Letter Channel - What will the messaging system do with a message it cannot deliver?

• Detour - How can you route a message through intermediate steps to perform validation, testing or debugging functions?

• Document Message - How can messaging be used to transfer data between applications?

• Durable Subscriber - How can a subscriber avoid missing messages while it is not listening for them?

• Dynamic Router - How can you avoid the dependency of the router on all possible destinations while maintaining its efficiency?

• Envelope Wrapper - How can existing systems participate in a messaging exchange that places specific requirements on the message format, such as message header fields or encryption?

• Event Message - How can messaging be used to transmit events from one application to another?

• Event-Driven Consumer - How can an application automatically consume messages as they become available?

• Format Indicator - How can a message`s data format be designed to allow for possible future changes?

• Guaranteed Delivery - How can the sender make sure that a message will be delivered, even if the messaging system fails?

• Idempotent Receiver - How can a message receiver deal with duplicate messages?

• Invalid Message Channel - How can a messaging receiver gracefully handle receiving a message that makes no sense?

• Message - How can two applications connected by a message channel exchange a piece of information?

• Message Dispatcher - How can multiple consumers on a single channel coordinate their message processing?

• Message Expiration - How can a sender indicate when a message should be considered stale and thus shouldn`t be processed?

• Message Translator - How can systems using different data formats communicate with each other using messaging?

• Message Broker - How can you decouple the destination of a message from the sender and maintain central control over the flow of messages?

• Message Bus - What is an architecture that enables separate applications to work together, but in a decoupled fashion such that applications can be easily added or removed without affecting the others?

• Message Channel - How does one application communicate with another using messaging?

• Message Endpoint - How does an application connect to a messaging channel to send and receive messages?

• Message Filter - How can a component avoid receiving uninteresting messages?

• Message History - How can we effectively analyze and debug the flow of messages in a loosely coupled system?

• Message Router - How can you decouple individual processing steps so that messages can be passed to different filters depending on a set of conditions?

• Message Sequence - How can messaging transmit an arbitrarily large amount of data?

• Message Store - How can we report against message information without disturbing the loosely coupled and transient nature of a messaging system?

• Messaging Bridge - How can multiple messaging systems be connected so that messages available on one are also available on the others?

• Messaging Gateway - How do you encapsulate access to the messaging system from the rest of the application?

• Messaging Mapper - How do you move data between domain objects and the messaging infrastructure while keeping the two independent of each other?

• Normalizer - How do you process messages that are semantically equivalent, but arrive in a different format?

• Pipes and Filters - How can we perform complex processing on a message while maintaining independence and flexibility?

• Point-to-Point Channel - How can the caller be sure that exactly one receiver will receive the document or perform the call?

• Polling Consumer - How can an application consume a message when the application is ready?

• Process Manager - How do we route a message through multiple processing steps when the required steps may not be known at design-time and may not be sequential?

• Publish-Subscribe Channel - How can the sender broadcast an event to all interested receivers?

• Recipient List - How do we route a message to a list of dynamically specified recipients?

• Request-Reply - When an application sends a message, how can it get a response from the receiver?

• Resequencer - How can we get a stream of related but out-of-sequence messages back into the correct order?

• Return Address - How does a replier know where to send the reply?

• Routing Slip - How do we route a message consecutively through a series of processing steps when the sequence of steps is not known at design-time and may vary for each message?

• Scatter-Gather - How do you maintain the overall message flow when a message needs to be sent to multiple recipients, each of which may send a reply?

• Selective Consumer - How can a message consumer select which messages it wishes to receive?

• Service Activator - How can an application design a service to be invoked both via various messaging technologies and via non-messaging techniques?

• Smart Proxy - How can you track messages on a service that publishes reply messages to the Return Address specified by the requestor?

• Splitter - How can we process a message if it contains multiple elements, each of which may have to be processed in a different way?

• Test Message - What happens, though, if a component is actively processing messages, but garbles outgoing messages due to an internal fault?

• Transactional Client - How can a client control its transactions with the messaging system?

• Wire Tap - How do you inspect messages that travel on a point-to-point channel?

Integration Patterns / Integration Architecture Patterns

• API-led Connectivity pattern (⭐3.4k) - Use APIs to connect different systems and applications.

• Anti Corruption Layer Pattern (⭐3.4k) - Add a layer to isolate and transform data between systems.

• Change Data Capture Pattern (⭐3.4k) - Capture and propagate changes made to a database or data source in real-time.

• Hybrid API Management pattern (⭐3.4k) - Manage APIs that span both cloud and on-premises environments using a central control plane.

• Hybrid Integration pattern (⭐3.4k) - Integrate systems and applications that are deployed both on-premises and in the cloud using a combination of integration technologies.

Integration Patterns / Microservice API Patterns

• Foundation
  • Frontend Integration - How can client-side end-user interfaces that are physically separated from server-side business logic and data storage be populated and updated with computing results, result sets from searches in data sources, and detailed information about data entities? How can application frontends invoke activities in a backend or upload data to it?
  • Backend Integration - How can distributed applications and their parts, which have been built independently and are deployed separately, exchange data and trigger mutual activity while preserving system-internal conceptual integrity without introducing undesired coupling?
  • Public API - How can an API be made available to an unlimited and/or unknown number of API clients outside the organization that are globally, nationally, and/or regionally distributed?
  • Community API - How can the visibility of and the access to an API be restricted to a closed user group that does not work for a single organizational unit but for multiple legal entities (such as companies, nonprofit/nongovernment organizations, and governments)?
  • Solution-Internal API - How can access to and usage of an API be limited to an application, for instance, components in the same or another logical layer and/or physical tier?
  • API Description - Which knowledge should be shared between an API provider and its clients? How should this knowledge be documented?

• Responsibility
  • Endpoint Roles
    • Processing Resource - How can an API provider allow its clients to trigger an action in it?
    • Information Holder Resource - How can domain data be exposed in an API, but its implementation still be hidden? How can an API expose data entities so that API clients can access and/or modify these entities concurrently without compromising data integrity and quality?
  • Operation Responsibilities
    • State Creation Operation - How can an API provider allow its clients to report that something has happened that the provider needs to know about, for instance, to trigger instant or later processing?
    • Retrieval Operation - How can information available from a remote party (the API provider, that is) be retrieved to satisfy an information need of an end user or to allow further client-side processing?
    • State Transition Operation - How can a client initiate a processing action that causes the provider-side application state to change? How can API clients and API providers share the responsibilities required to execute and control business processes and their activities?
    • Computation Function - How can a client invoke side-effect-free remote processing on the provider side to have a result calculated from its input?
  • Information Holder Types
    • Operational Data Holder - How can an API support clients that want to create, read, update, and/or delete instances of domain entities that represent operational data: data that is rather short-lived, changes often during daily business operations, and has many outgoing relations?
    • Master Data Holder - How can I design an API that provides access to master data that lives for a long time, does not change frequently, and will be referenced from many clients?
    • Reference Data Holder - How should data that is referenced in many places, lives long, and is immutable for clients be treated in API endpoints? How can such reference data be used in requests to and responses from Processing Resources or Information Holder Resources?
    • Link Lookup Resource - How can message representations refer to other, possibly many and frequently changing, API endpoints and operations without binding the message recipient to the actual addresses of these endpoints?
    • Data Transfer Resource - How can two or more communication participants exchange data without knowing each other, without being available at the same time, and even if the data has already been sent before its recipients became known?

• Structure
  • Representation Elements
    • Atomic Parameter - How can simple, unstructured data (such as a number, a string, a Boolean value, or a block of binary data) be exchanged between API client and API provider?
    • Atomic Parameter List - How can multiple related Atomic Parameters be combined in a representation element so that each of them stays simple, but their relatedness becomes explicit in the API Description and the runtime message exchanges?
    • Parameter Tree - How can containment relationships be expressed when defining complex representation elements and exchanging such related elements at runtime?
    • Parameter Forest - How can multiple Parameter Trees be exposed as request or response payload of an API operation?
  • Element Stereotypes
    • Data Element - How can domain/application-level information be exchanged between API clients and API providers without exposing provider-internal data definitions in the API? How can API client and API provider be decoupled from a data management point of view?
    • Metadata Element - How can messages be enriched with additional information so that receivers can interpret the message content correctly, without having to hardcode assumptions about the data semantics?
    • Id Element - How can API elements be distinguished from each other at design time and at runtime? When applying domain-driven design, how can elements of the Published Language be identified?
    • Link Element - How can API endpoints and operations be referenced in request and response message payloads so that they can be called remotely?
  • Special Purpose Representations
    • API Key - How can an API provider identify and authenticate clients and their requests?
    • Error Report - How can an API provider inform its clients about communication and processing faults? How can this information be made independent of the underlying communication technologies and platforms (for example, protocol-level headers representing status codes)?
    • Context Representation - How can API consumers and providers exchange context information without relying on any particular remoting protocols? How can identity information and quality properties in a request be made visible to related subsequent ones in conversations?

• Quality

  • Reference Management

    • Embedded Entity - How can one avoid sending multiple messages when their receivers require insights about multiple related information elements?
    • Linked Information Holder - How can messages be kept small even when an API deals with multiple information elements that reference each other?

  • Data Transfer Parsimony

    • Pagination - How can messages be kept small even when an API deals with multiple information elements that reference each other?
    • Wish List - How can an API client inform the API provider at runtime about the data it is interested in?
    • Wish Template - How can an API client inform the API provider about nested data that it is interested in? How can such preferences be expressed flexibly and dynamically?
    • Conditional Request - How can unnecessary server-side processing and bandwidth usage be avoided when frequently invoking API operations that return rarely changing data?
    • Request Bundle - How can the number of requests and responses be reduced to increase communication efficiency?

  • Quality Management and Governance

    • Pricing Plan - How can the API provider meter API service consumption and charge for it?
    • Rate Limit - How can the API provider prevent API clients from excessive API usage?
    • Service Level Agreement - How can an API client learn about the specific quality-of-service characteristics of an API and its endpoint operations? How can these characteristics, and the consequences of not meeting them, be defined and communicated in a measurable way?

• Evolution
  • Version Identifier - How can an API provider indicate its current capabilities as well as the existence of possibly incompatible changes to clients in order to prevent malfunctioning of clients due to undiscovered interpretation errors?
  • Semantic Versioning - How can stakeholders compare API versions to detect immediately whether they are compatible?
  • Two In Production - How can a provider gradually update an API without breaking existing clients but also without having to maintain a large number of API versions in production?
  • Aggressive Obsolescence - How can API providers reduce the effort for maintaining an entire API or its parts (such as endpoints, operations, or message representations) with guaranteed service quality levels?
  • Experimental Preview - How can providers make the introduction of a new API, or new API version, less risky for their clients and obtain early adopter feedback without having to freeze the API design prematurely?
  • Limited Lifetime Guarantee - How can a provider let clients know for how long they can rely on the published version of an API?
  • Eternal Lifetime Guarantee - How can a provider support clients that are unable or unwilling to migrate to newer API versions at all?

Integration Patterns / SOA Patterns

• Foundational Inventory Patterns
  • Canonical Protocol - Defines a common communication protocol between services to enable interoperability and decoupling.
  • Canonical Schema - Defines a standard data model and format for exchanging data between services.
  • Domain Inventory - Identifies and categorizes the types of services within a particular domain.
  • Enterprise Inventory - Identifies and categorizes the types of services within a particular domain.
  • Logic Centralization - Centralizes business logic within a service layer to reduce redundancy and promote consistency.
  • Service Layers - Centralizes business logic within a service layer to reduce redundancy and promote consistency.
  • Service Normalization - Centralizes business logic within a service layer to reduce redundancy and promote consistency.

• Logical Inventory Layer Patterns
  • Entity Abstraction - Abstracts data entities to simplify data access and reduce coupling.
  • Process Abstraction - Abstracts processes to improve reusability and maintainability.
  • Utility Abstraction - Abstracts common utilities to reduce duplication and promote consistency.
  • Micro Task Abstraction - Breaks down tasks into smaller, more granular tasks for easier management.

• Inventory Centralization Patterns
  • Policy Centralization - Centralizes policies to reduce duplication and improve consistency.
  • Process Centralization - Centralizes processes to improve reusability and maintainability.
  • Rules Centralization - Centralizes business rules to reduce duplication and promote consistency.
  • Schema Centralization - Centralizes data schemas to reduce duplication and improve consistency.

• Inventory Implementation Patterns
  • Canonical Resources - Defines a standard set of resources for common functionality across services.
  • Cross-Domain Utility Layer - Uses multiple protocols for improved performance and flexibility.
  • Dual Protocols - Defines a common utility layer across multiple domains.
  • Inventory Endpoint - Defines a standard endpoint for accessing inventory resources.
  • Service Grid - Provides a framework for managing and scaling services.
  • State Repository - Stores and manages service state information.
  • Stateful Services - Maintains state information across service invocations.
  • Augmented Protocols - Enhances protocols with additional features.

• Inventory Governance Patterns
  • Canonical Expression - Defines a standard expression language for inventory data.
  • Canonical Versioning - Defines a standard versioning scheme for inventory resources.
  • Metadata Centralization - Centralizes metadata to reduce duplication and improve consistency.

• Foundational Service Patterns
  • Agnostic Capability - Abstracts service capabilities for improved flexibility.
  • Agnostic Context - Abstracts service context for improved flexibility.
  • Functional Decomposition - Breaks down services into smaller, more manageable components.
  • Non-Agnostic Context - Breaks down services into smaller, more manageable components.
  • Service Encapsulation - Encapsulates service functionality for improved maintainability.

• Service Implementation Patterns
  • Partial State Deferral - Encapsulates service functionality for improved maintainability.
  • Partial Validation - Validates only relevant data for improved performance.
  • Redundant Implementation - Implements multiple versions of a service for improved flexibility.
  • Service Data Replication - Replicates data across multiple services for improved performance.
  • Service Façade - Provides a simplified interface to a complex service for improved usability.
  • UI Mediator - Mediates between the user interface and underlying services for improved usability.
  • Reference Data Centralization - Centralizes reference data to reduce duplication and improve consistency.
  • Microservice Deployment - Deploys services as independent, autonomous units for improved scalability and resilience.
  • Containerization - How can an environment be provided with maximum support for services with high-performance recovery and scalability requirements?

• Service Security Patterns
  • Exception Shielding - Protects against security vulnerabilities through proper handling of exceptions.
  • Message Screening - Screens messages for malicious content.
  • Service Perimeter Guard - Guards the service perimeter to prevent unauthorized access.
  • Trusted Subsystem - Establishes trust between subsystems for improved security.

• Service Contract Design Patterns
  • Concurrent Contracts - Allows multiple versions of a service contract to coexist simultaneously.
  • Contract Centralization - Centralizes service contracts to improve consistency and reduce duplication.
  • Contract Denormalization - Centralizes service contracts to improve consistency and reduce duplication.
  • Decoupled Contract - Decouples service contracts from their implementation for improved flexibility.
  • Validation Abstraction - Abstracts validation logic to improve reusability and maintainability.

• Legacy Encapsulation Patterns
  • File Gateway - Provides a gateway to access legacy file-based systems.
  • Legacy Wrapper - Wraps legacy systems to expose them as services.
  • Multi-Channel Endpoint - Provides multiple communication channels to access legacy systems.

• Service Governance Patterns
  • Compatible Change - Enables changes to a service without breaking existing clients.
  • Decomposed Capability - Breaks down a service capability into smaller, more manageable pieces.
  • Distributed Capability - Breaks down a service capability into smaller, more manageable pieces.
  • Proxy Capability - Provides a proxy to a remote service capability to improve performance and reduce network overhead.
  • Service Decomposition - Breaks down a monolithic service into smaller, more manageable pieces.
  • Service Refactoring - Refactors a service to improve its design and performance.
  • Termination Notification - Notifies clients of a service's termination.
  • Version Identification - Identifies the version of a service.

• Capability Composition Patterns
  • Capability Composition - Combines multiple service capabilities to create a new capability.
  • Capability Recomposition - Recombines existing service capabilities to create a new capability.

• Service Messaging Patterns
  • Asynchronous Queuing - Uses a message queue to decouple services and improve scalability and reliability.
  • Event-Driven Messaging - Uses events to trigger service invocations and reduce coupling.
  • Intermediate Routing - Uses intermediate routing nodes to improve performance and flexibility.
  • Messaging Metadata - Uses metadata to describe and manage service messages.
  • Reliable Messaging - Ensures message delivery and reliability in a distributed environment.
  • Service Agent - Acts as a proxy for a remote service to improve performance and reduce network overhead.
  • Service Callback - Uses callbacks to communicate between services.
  • Service Instance Routing - Routes messages based on the service instance to improve performance and scalability.
  • Service Messaging - Describes the communication between services.
  • State Messaging - Uses messages to manage state information in a distributed environment.

• Composition Implementation Patterns
  • Agnostic Sub-Controller - Separates sub-controllers from the main controller to improve reusability and maintainability.
  • Atomic Service Transaction - Uses transactions to ensure atomicity and consistency across multiple service invocations.
  • Compensating Service Transaction - Reverses the effects of a failed transaction.
  • Composition Autonomy - Enables services to act autonomously within a composition.

• Service Interaction Security Patterns
  • Brokered Authentication - Authenticates clients through a broker.
  • Data Confidentiality - Ensures data confidentiality in a distributed environment.
  • Data Origin Authentication - Authenticates the origin of a message.
  • Direct Authentication - Authenticates clients directly.

• Transformation Patterns
  • Data Format Transformation - Transforms data formats to enable interoperability.
  • Data Model Transformation - Transforms data models to enable interoperability.
  • Protocol Bridging - Bridges between different protocols to enable interoperability.

• REST-inspired Patterns
  • Entity Linking - Links related resources to enable navigation and discovery.
  • Lightweight Endpoint - Provides a lightweight endpoint for resource access.
  • Reusable Contract - Reuses common contracts to improve consistency and reduce duplication.
  • Content Negotiation - Negotiates the content format between clients and servers.
  • Endpoint Redirection - Redirects clients to alternative endpoints.
  • Idempotent Capability - Ensures that the same action can be performed multiple times without changing the system state.

51. Awesome Docker

Monitoring Services / Other

• Better Stack 💲 - A Docker-compatible observability stack that delivers robust log aggregation and uptime monitoring capabilities for various software application.

52. Awesome Agi Cocosci

Commonsense / Intuitive Physics

• Intuitive Physics Reading List (⭐15) - GitHub. A reading list on intuitive physics, maintained actively by Shiqian Li.

53. Awesome Remote Job

Companies with "remote DNA"

• Docker -

54. Awesome Newsletters

Ruby / Svelte

• Rails Weekly. Weekly inside scoop of interesting commits, pull requests and more from Rails, delivered to your inbox every Friday.

55. Awesome Langchain

LangChain Framework

• Langchain Blog: The Official Langchain blog

Learn / Videos Playlists

• LangChain Series by Sam Witteveen

• Prev: Apr 24 - Apr 30, 2023
• Next: Apr 10 - Apr 16, 2023