Awesome List Updates on Apr 17, 2023

15 awesome lists updated today.

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

1. Awesome K6

Articles

• Load testing with k6 and k8s - The Toucan DevOps team explains why they chose k6 as their load testing tool and how they deploy it on k8s.

2. Awesome Integration

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.

3. Awesome Neovim

Formatting / Diagnostics

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

4. Awesome Sysadmin

Software / Automation

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

5. Awesome Developer First

Analytics

• PostHog - Open-source product analytics platform.

6. 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.

7. Awesome Langchain

Learn / Videos Playlists

• LangChain Series by Sam Witteveen

8. Awesome Remote Job

Companies with "remote DNA"

• Docker -

9. Awesome Embedded Rust

Real-time / Real-time tools

• RTIC v1.0 Real-Time Interrupt-driven Concurrency — A concurrency framework for building real-time systems:
  • cortex-m rtic (⭐1.6k) RTIC framework for ARM Cortex-M microcontrollers
  • msp430 rtfm (⭐11) RTFM framework for MSP430 MCUs

10. Awesome Nix

Programming Languages / OCaml

• opam2nix (⭐93) - Generate Nix expressions from opam packages.

11. Awesome Gnome

Gaming

• Cartridges (⭐482) - Game launcher with Steam, Lutris, Heroic, Bottles and itch library import.

12. Awesome Computational Biology

Databases / scRNA

• Gene Expression Omnibus - Public functional genemics database.

• Single Cell PORTAL - Public database for single cell RNA.

13. Free for Dev

Design and UI

• Vertopal - Vertopal is a free online platform for converting files to various formats. Including developer converters like JPG to SVG, GIF to APNG, PNG to WEBP, JSON to XML, etc.

14. Awesome Angular

General / Components

• NgLazyLoadComponent . Lazy load Angular component into HTML template without routing.

15. Awesome Newsletters

Ruby / Svelte

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

• Prev: Apr 18, 2023
• Next: Apr 16, 2023