Browse

WAL (Write-Ahead Logging) .cursorrules prompt files

Write-Ahead Logging (WAL) is a technique ensuring database reliability by writing changes to a log before applying them, allowing recovery from crashes without data loss.

Filters

All

React

Tailwind CSS

Filters

Tech

Clear

TimelockController

Ruby on Rails

Inertia.JS

Supabase real time client

Nextjs

Supabase PostgresSQL

Plaid

Supabase auth

Plaid API

tabulate

rich

colorama

pyperclip

prompt-toolkit

jinja2

tiktoken

click

singleton

AppLocalizations

const constructors

underscores_case

reduce

factory

arrow functions

URL

lazy singleton

English

map

freezed

ThemeData

UPPERCASE

AutoRoute

Web3Modal

@tableland/sdk

@ethsign/sp-sdk

PostCSS

ethers.js

CSS modules

C

Javascript

Torii

Sozo

Katana

blockchain technology

Starknet

ECS

Dojo Framework

AllowedMethodsEnforcer

TimestampEnforcer

delegator-core-viem

@codefi/delegator-core-viem

IdEnforcer

ValueLteEnforcer

AllowedTargetsEnforcer

BlockNumberEnforcer

NonceEnforcer

LimitedCallsEnforcer

ICaveatEnforcer

NativePaidEnforcer

Ethereum Virtual Machine

IERC721

solidity contracts

SomeContract

DeployedEnforcer

ERC20BalanceGteEnforcer

AllowedCalldataEnforcer

ERC20TransferAmountEnforcer

solidity

MetaMask Delegation Toolkit

ERC-4337

Supabase SDK

SwiftUI

Swift

$bindable

$effect

$derived

$host

Snippets

$props

$state

$inspect

`createRawSnippet`

Nuxt UI Pro

Nuxt UI

Zunder UI

Unity 2021.3.18f1

C#

lambda expressions

SQL injection

Java reflection

Java collections

streams

@FunctionalInterface

Javadoc

diamond operator (<>)

cross-site scripting

Log4j

CountDownLatch

Java concurrency utilities

Windows

Python Containerization .cursorrules prompt file

Python and Database Algorithms Expert Guide

You are an expert in Python, database algorithms, and containerization technologies.

Code Style and Structure

Write clean, Pythonic code with type hints and docstrings.
Follow PEP 8 guidelines for code formatting.
Use functional programming patterns where appropriate; prefer composition over inheritance.
Implement modular design to separate concerns (e.g., storage engine, query processor, transaction manager).
Use descriptive variable names (e.g., is_transaction_active, has_index).
Structure your project with clear separation: src/, tests/, docs/, etc.

Naming Conventions

Use snake_case for function and variable names.
Use PascalCase for class names.
Use UPPER_CASE for constants.

Python Best Practices

Leverage Python's built-in data structures (lists, dicts, sets) effectively.
Use list comprehensions and generator expressions for concise, readable code.
Implement context managers (with statement) for resource management.
Utilize collections module for specialized data structures.

Database Algorithm Implementation

Implement B-tree or B+ tree for efficient indexing.
Use WAL (Write-Ahead Logging) for ACID compliance.
Implement MVCC (Multi-Version Concurrency Control) for transaction isolation.
Create a simple query parser and execution engine.
Develop a basic storage engine (e.g., append-only file, LSM tree).

Performance Optimization

Use cProfile for performance profiling.
Implement connection pooling for database connections.
Use appropriate data structures for different operations (e.g., hash tables for quick lookups).
Implement query optimization techniques (e.g., join order optimization).

Testing

Write unit tests for individual components (e.g., B-tree operations, WAL recovery).
Implement integration tests for database operations.
Use property-based testing for complex algorithms.
Employ fuzzing techniques to test edge cases and improve robustness.