phoenix-patterns
Use when applying Phoenix Framework best practices including context design, controller patterns, and application architecture. Use when building Phoenix applications.
phoenix-routing
Define routes and URL helpers in Phoenix applications including resources, scopes, pipelines, and verified routes
phoenix-views-templates
Render views and templates in Phoenix using HEEx templates, function components, slots, and assigns
rails-action-controller-patterns
Use when action Controller patterns including routing, filters, strong parameters, and REST conventions.
rails-active-record-patterns
Use when active Record patterns including models, associations, queries, validations, and callbacks.
rails-hotwire
Use when hotwire (Turbo and Stimulus) for building modern reactive Rails applications without complex JavaScript frameworks.
react-native-web-core
Use when working with React Native Web projects. Provides core concepts, components, and cross-platform patterns for building web applications with React Native.
react-native-web-navigation
Use when implementing navigation in React Native Web projects. Provides patterns for React Navigation, deep linking, and web-specific routing.
react-native-web-performance
Use when optimizing React Native Web performance. Provides patterns for code splitting, bundle optimization, memoization, and web-specific performance improvements.
react-native-web-styling
Use when styling React Native Web components. Provides patterns for StyleSheet API, platform-specific styles, responsive design, and theming.
react-native-web-testing
Use when testing React Native Web applications. Provides patterns for Jest, React Native Testing Library, component testing, and web-specific testing strategies.
react-context-patterns
Use when React Context patterns for state management. Use when sharing state across component trees without prop drilling.
react-hooks-patterns
Use when React Hooks patterns including useState, useEffect, useContext, useMemo, useCallback, and custom hooks. Use for modern React development.
react-performance
Use when React performance optimization including memoization, lazy loading, and virtualization. Use when optimizing React applications.
relay-fragments-patterns
Use when relay fragment composition, data masking, colocation, and container patterns for React applications.
relay-mutations-patterns
Use when relay mutations with optimistic updates, connections, declarative mutations, and error handling.
relay-pagination
Use when relay pagination with cursor-based pagination, infinite scroll, load more patterns, and connection protocols.
vue-component-patterns
Use when Vue component patterns including props, emits, slots, and provide/inject. Use when building reusable Vue components.
vue-composition-api
Use when Vue 3 Composition API with reactive refs, computed, and composables. Use when building modern Vue 3 applications.
vue-reactivity-system
Use when Vue reactivity system with refs, reactive, computed, and watchers. Use when managing complex state in Vue applications.
zustand-advanced-patterns
Use when implementing advanced Zustand patterns including transient updates, subscriptions with selectors, store composition, and performance optimization techniques.
zustand-middleware
Use when implementing Zustand middleware for persistence, dev tools, immutability, and other enhanced store functionality. Covers persist, devtools, immer, and custom middleware.
zustand-store-patterns
Use when creating and managing Zustand stores for React state management. Covers store creation, selectors, actions, and basic usage patterns.
zustand-typescript
Use when working with Zustand in TypeScript projects. Covers type-safe store creation, typed selectors, and advanced TypeScript patterns with Zustand.
c-data-structures
Use when fundamental C data structures including arrays, structs, linked lists, trees, and hash tables with memory-efficient implementations.
c-systems-programming
Use when c systems programming including file I/O, processes, signals, and system calls for low-level system interaction.
c-memory-management
Use when managing memory in C programs with malloc/free, pointers, and avoiding common memory safety pitfalls.
cpp-modern-features
Use when modern C++ features from C++11/14/17/20 including auto, lambdas, range-based loops, structured bindings, and concepts.
cpp-smart-pointers
Use when C++ smart pointers including unique_ptr, shared_ptr, and weak_ptr for automatic memory management following RAII principles.
cpp-templates-metaprogramming
Use when C++ templates and metaprogramming including template specialization, SFINAE, type traits, and C++20 concepts.
crystal-concurrency
Use when implementing concurrent programming in Crystal using fibers, channels, and parallel execution patterns for high-performance, non-blocking applications.
crystal-engineer
Use when working with Crystal language development including WebSocket communication, TLS/SSL configuration, HTTP frameworks, ORM operations, and high-performance concurrent systems.
crystal-macros
Use when implementing compile-time metaprogramming in Crystal using macros for code generation, DSLs, compile-time computation, and abstract syntax tree manipulation.
csharp-async-patterns
Use when C# asynchronous programming with async/await, Task, ValueTask, ConfigureAwait, and async streams for responsive applications.
csharp-linq
Use when lINQ (Language Integrated Query) with query and method syntax, deferred execution, expression trees, and performance optimization.
csharp-nullable-types
Use when C# nullable reference types and value types for null safety, nullable annotations, and patterns for handling null values.
elixir-ecto-patterns
Use when Elixir Ecto patterns including schemas, changesets, queries, and transactions. Use when building database-driven Elixir applications.
elixir-otp-patterns
Use when Elixir OTP patterns including GenServer, Supervisor, Agent, and Task. Use when building concurrent, fault-tolerant Elixir applications.
elixir-pattern-matching
Use when Elixir pattern matching including function clauses, case statements, with statements, and destructuring. Use for elegant control flow.
Erlang Concurrency
Use when erlang's concurrency model including lightweight processes, message passing, process links and monitors, error handling patterns, selective receive, and building massively concurrent systems on the BEAM VM.
Erlang Distribution
Use when erlang distributed systems including node connectivity, distributed processes, global name registration, distributed supervision, network partitions, and building fault-tolerant multi-node applications on the BEAM VM.
Erlang OTP Behaviors
Use when oTP behaviors including gen_server for stateful processes, gen_statem for state machines, supervisors for fault tolerance, gen_event for event handling, and building robust, production-ready Erlang applications with proven patterns.
Gleam Actor Model
Use when oTP actor patterns in Gleam including processes, message passing, GenServer implementations, supervisors, fault tolerance, state management, and building concurrent, fault-tolerant applications on the Erlang VM.
Gleam Erlang Interop
Use when gleam-Erlang interoperability including calling Erlang code from Gleam, using Erlang libraries, external functions, working with Erlang types, NIFs, and leveraging the BEAM ecosystem from Gleam applications.
Gleam Type System
Use when gleam's type system including algebraic data types, custom types, pattern matching, generic types, type inference, opaque types, exhaustive checking, and functional error handling for building type-safe Erlang VM applications.
go-error-handling
Use when Go error handling with error wrapping, sentinel errors, and custom error types. Use when handling errors in Go applications.
go-interfaces
Use when Go interfaces including interface design, duck typing, and composition patterns. Use when designing Go APIs and abstractions.
java-concurrency
Use when Java concurrency with ExecutorService, CompletableFuture, and virtual threads. Use when building concurrent applications.
java-generics
Use when Java generics including type parameters, wildcards, and type bounds. Use when writing type-safe reusable code.
java-streams-api
Use when Java Streams API for functional-style data processing. Use when processing collections with streams.
Page 832 of 1446 · 72294 results