Results for “concurrent”

Swift 6.2 Approachable Concurrency — デフォルトでシングルスレッド、明示的なバックグラウンドオフロードに@concurrent、メインアクター型の分離適合。

The English summary is being prepared. Showing the original description.

Performance optimization guidelines for OneKey React/React Native applications. Use when optimizing app performance, fixing UI freezes/lag, reducing re-renders, handling concurrent operations, or analyzing performance bottlenecks. Triggers on performance, optimization, optimize, slow, lag, freeze, hang, jank, stutter, memory, leak, concurrent, batching, batch, memoization, memo, bridge, windowSize, contentVisibility, FlashList, re-render, fps, tti, bundle.

The English summary is being prepared. Showing the original description.

Use when you need to apply Java concurrency best practices — including thread safety fundamentals, ExecutorService thread pool management, concurrent design patterns like Producer-Consumer, asynchronous programming with CompletableFuture, immutability and safe publication, deadlock avoidance, virtual threads and structured concurrency, scoped values, backpressure, cancellation discipline, and observability for concurrent systems. Part of the skills-for-java project

The English summary is being prepared. Showing the original description.

Plan database structure changes and existing data updates for production systems. Provides migration patterns for adding columns and indexes, switching applications in stages, and documenting recovery steps while accounting for downtime and database locks.

• Adding columns or indexes to production tables
• Updating large datasets in batches
• Planning a staged column replacement without downtime

Design local data storage in Swift using actors, which control concurrent access to shared data. Combine an in-memory cache with JSON file storage, implement save and lookup operations, and connect the repository to an observable ViewModel.

• Building local storage for an iOS or macOS app
• Designing local storage for an offline-first app
• Replacing lock-based synchronization with Swift actors

Write, review, and refactor Rust code using established conventions for ownership, error handling, type design, and concurrency. It guides safer implementations, avoids unnecessary copying, and organizes modules with a limited public interface.

• Review ownership and borrowing in Rust code
• Replace panic-prone error handling
• Design types and modules for a Rust application

Coordinate coding projects through Claude DevFleet by splitting work into dependent tasks and dispatching Claude Code agents in separate Git working directories. Monitor progress, manage automatic task sequencing, and review structured reports of changes, tests, and errors.

• Splitting a coding project into dependent tasks
• Running coding agents in separate Git working directories
• Monitoring concurrent development tasks

Review a codebase for bugs, security risks, failures under expected load, missing tests, slow paths, and unnecessary code. Receive prioritized findings with concrete failure cases, small proposed fixes, and the consequences of leaving each issue unresolved.

• Assess the quality of an inherited codebase
• Find risks under expected concurrent usage
• Identify unnecessary code and dependencies

Extract website content into Markdown, HTML, or plain text with Scrapling. Handle JavaScript-rendered pages and anti-bot challenges, or write Python crawlers that follow links, collect structured data, and resume interrupted runs.

• Save article text as Markdown
• Extract content loaded by JavaScript
• Retrieve pages with anti-bot protections

Check whether an application is ready for production by finding unfinished code and testing real database and API connections. Review performance under load, authentication, environment settings, and deployment behavior to identify gaps before release.

• Finding unfinished code before release
• Testing real database and API integrations
• Checking performance under concurrent requests

Coordinate gossip protocols, where nodes pass information among peers, for distributed systems. The skill covers update propagation, state synchronization, conflicting changes, failure detection, and tuning communication so nodes eventually reach a consistent state.

• Designing update propagation between distributed nodes
• Synchronizing state and resolving concurrent changes
• Managing node membership and detecting failures

Implement Azure Cosmos DB data operations in JavaScript or TypeScript with @azure/cosmos. Covers creating, querying, updating, and deleting documents, plus bulk operations, container setup, and checks that prevent concurrent changes from overwriting each other.

• Implement document creation, retrieval, updates, and deletion
• Build filtered queries with pagination
• Process multiple document operations in bulk

Helps implement centralized settings management in Java with Azure App Configuration. Covers environment-specific settings, feature flags that control feature availability, and snapshots that preserve settings at a particular point in time.

• Manage settings separately for development and production
• Configure feature flags for gradual rollouts
• Preserve release settings in snapshots

Modernize existing React applications through version upgrades and migration from class components to Hooks, functions for state and lifecycle behavior. Includes React 18 rendering APIs, grouped state updates, and features for prioritizing interface updates.

• Plan an upgrade from React 16 through React 18
• Rewrite class components with Hooks
• Extract shared logic into custom Hooks

Break a large development brief into ordered goals and save plans, progress events, blockers, and evidence in the repository. Coordinate Claude Code sessions through handoff instructions, with final completion requiring cleanup, verification, and code review evidence.

• Tracking development work across Claude Code sessions
• Managing ordered goals with attempts and evidence
• Requiring cleanup, verification, and review before completion

Calculate how to divide serving memory between recurrent state and KV cache, two memory pools used by hybrid models. Use startup logs and workload settings to recommend a ratio, estimate concurrency, and identify the limiting pool.

• Choosing a memory ratio for a hybrid model
• Investigating limits on concurrent requests
• Recalculating memory allocation for context length

Approach engineering problems by checking assumptions, defining performance constraints, and choosing suitable tools before implementation. The skill guides algorithm analysis, complete code, performance optimization, and correctness checks through tests, assertions, or formal verification, meaning mathematical checks of correctness.

• Checking algorithm complexity and design assumptions
• Choosing languages for numerical or distributed systems
• Implementing concurrent code with explicit error handling

Plan and, after explicit approval, run controlled checks of software behavior. Compare baseline and failure cases, repeat sensitive measurements, and report observed results with execution context, comparison conditions, and the status of temporary evidence files.

• Investigating a suspected runtime regression
• Checking retries, interruptions, and concurrent operations
• Comparing latency or cost under matched conditions

Assess GitHub issues and pull requests by checking demonstrated user needs, existing alternatives, compatibility, and maintenance costs. Produce an evidence-based maintainer recommendation through code and document inspection, without running tests or examples.

• Deciding whether a pull request merits merging
• Checking whether existing features already solve an issue
• Comparing competing fixes for the same problem

Investigate difficult bugs by adding temporary logs to the actual execution path and reproducing the reported behavior. Analyze JSONL logs, which store one structured event per line, then fix the cause, verify regression tests, and remove debugging artifacts.

• Investigating bugs that occur only during manual use
• Tracing event order in streaming or concurrent operations
• Checking whether passing tests cover the reported bug

Use German-language guidance to organize multi-step agent work in Markdown files. Store plans, findings, and progress by task, then revisit those records to resume research, review decisions, and track unfinished phases.

• Managing research with German-language guidance
• Recovering task context after a break
• Separating plans for concurrent tasks

Organize multi-step research and project work with Markdown files for plans, findings, and progress. Gemini hooks, automatic actions at session events, surface planning context so the agent can resume from saved records.

• Resuming research after a break
• Tracking project phases and decisions
• Recording errors and test results

Keep plans, research findings, and progress in Markdown files for complex agent work. Separate task plans and automatic planning reminders help the agent recover saved context, track decisions, and identify the next action.

• Resuming long research tasks
• Tracking phases and the next action
• Separating plans for concurrent tasks

Build live backends that store data, broadcast changes, and run handlers automatically. Covers subscription authorization, connection events, and atomic updates, which apply changes safely when multiple writers act at once.

• Broadcasting live data changes to subscribers
• Checking permissions before a subscription starts
• Tracking connections and disconnections