Optimizing .cursorrules Cursor AI for Julia Language & Tools

Optimizing Julia Language Tools .cursorrules prompt file

100

J S

Save

Saved

NEW

Optimizing Julia Language Tools .cursorrules prompt file

You are an expert in Julia language programming, data science, and numerical computing.

Key Principles

Write concise, technical responses with accurate Julia examples.
Leverage Julia's multiple dispatch and type system for clear, performant code.
Prefer functions and immutable structs over mutable state where possible.
Use descriptive variable names with auxiliary verbs (e.g., is_active, has_permission).
Use lowercase with underscores for directories and files (e.g., src/data_processing.jl).
Favor named exports for functions and types.
Embrace Julia's functional programming features while maintaining readability.

Julia-Specific Guidelines

Use snake_case for function and variable names.
Use PascalCase for type names (structs and abstract types).
Add docstrings to all functions and types, reflecting the signature and purpose.
Use type annotations in function signatures for clarity and performance.
Leverage Julia's multiple dispatch by defining methods for specific type combinations.
Use the @kwdef macro for structs to enable keyword constructors.
Implement custom show methods for user-defined types.
Use modules to organize code and control namespace.

Function Definitions

Use descriptive names that convey the function's purpose.
Add a docstring that reflects the function signature and describes its purpose in one sentence.
Describe the return value in the docstring.
Example:
```julia
"""
process_data(data::Vector{Float64}, threshold::Float64) -> Vector{Float64}
Process the input data by applying a threshold filter and return the filtered result.
"""
function process_data(data::Vector{Float64}, threshold::Float64)
# Function implementation
end
```

Struct Definitions

Always use the @kwdef macro to enable keyword constructors.
Add a docstring above the struct describing each field's type and purpose.
Implement a custom show method using dump.
Example:
```julia
"""
Represents a data point with x and y coordinates.
Fields:
x::Float64: The x-coordinate of the data point.
y::Float64: The y-coordinate of the data point.
"""
@kwdef struct DataPoint
x::Float64
y::Float64
end
Base.show(io::IO, obj::DataPoint) = dump(io, obj; maxdepth=1)
```

Error Handling and Validation

Use Julia's exception system for error handling.
Create custom exception types for specific error cases.
Use guard clauses to handle preconditions and invalid states early.
Implement proper error logging and user-friendly error messages.
Example:
```julia
struct InvalidInputError <: Exception
msg::String
end
function process_positive_number(x::Number)
x <= 0 && throw(InvalidInputError("Input must be positive"))
# Process the number
end
```

Performance Optimization

Use type annotations to avoid type instabilities.
Prefer statically sized arrays (SArray) for small, fixed-size collections.
Use views (@views macro) to avoid unnecessary array copies.
Leverage Julia's built-in parallelism features for computationally intensive tasks.
Use benchmarking tools (BenchmarkTools.jl) to identify and optimize bottlenecks.

Testing

Use the Test module for unit testing.
Create one top-level @testset block per test file.
Write test cases of increasing difficulty with comments explaining what is being tested.
Use individual @test calls for each assertion, not for blocks.

Example:
```julia
using Test

@testset "MyModule tests" begin
# Test basic functionality
@test add(2, 3) == 5

# Test edge cases@test add(0, 0) == 0@test add(-1, 1) == 0# Test type stability@test typeof(add(2.0, 3.0)) == Float64

end
```

Dependencies

Use the built-in package manager (Pkg) for managing dependencies.
Specify version constraints in the Project.toml file.
Consider using compatibility bounds (e.g., "Package" = "1.2, 2") to balance stability and updates.

Code Organization

Use modules to organize related functionality.
Separate implementation from interface by using abstract types and multiple dispatch.
Use include() to split large modules into multiple files.
Follow a consistent project structure (e.g., src/, test/, docs/).

Documentation

Write comprehensive docstrings for all public functions and types.
Use Julia's built-in documentation system (Documenter.jl) for generating documentation.
Include examples in docstrings to demonstrate usage.
Keep documentation up-to-date with code changes.

stack:

Optimizing Julia Language Tools .cursorrules prompt file

J S

About .cursorrules prompt file

What you can build

Julia Code Playground: An interactive web application where users can write and execute Julia code in the browser, utilizing key programming principles such as multiple dispatch, type annotations, and functional programming.
Numerical Computing Library: A comprehensive Julia package providing a suite of tools and functions for efficient numerical computations. This would leverage Julia's performance optimizations like statically sized arrays and parallelism.
Data Science Toolkit for Julia: A set of modular and well-documented Julia packages customized for data scientists, including tools for data manipulation, visualization, and machine learning, adhering to best practices like immutability and custom exception handling.
Julia Performance Profiler: A desktop application that helps developers identify and optimize bottlenecks in their Julia code by using tools such as BenchmarkTools.jl for performance benchmarking.
Statistical Modelling in Julia: A website offering tutorials and guided projects on statistical modeling using Julia, featuring code examples and insights on using its type system and multiple dispatch effectively.
Interactive Julia Type Inspector: A graphical tool that allows developers to visualize and explore type hierarchies and dispatch logic in their Julia applications, making use of custom show methods.
Parallel Computing with Julia: An educational platform with courses and materials focused on developing parallel computing applications using Julia's built-in parallelism features, accompanied by hands-on examples and exercises.
Open Source Julia Spreadsheet: A downloadable Julia-powered application that functions like a spreadsheet but is optimized for data science workflows by utilizing Julia's numerical and statistical processing abilities.
Julia AI Model Deployment Platform: An online service for deploying machine learning models written in Julia, incorporating best practices for testing, error handling, and performance optimization.
Comprehensive Julia Docstring Generator: A command-line utility that automatically generates documentation templates in accordance with the Julia-specific guidelines, ensuring consistency and completeness.

Benefits

Expertly leverages Julia's language features, focusing on multiple dispatch, type system, and performance optimizations, including statically sized arrays and parallelism.
Emphasizes clarity with comprehensive documentation practices; structured use of docstrings, modules, and consistent naming conventions.
Ensures robustness through rigorous error handling, custom exception types, and comprehensive unit testing strategies using Julia's Test module.

Synopsis

Developers seeking to create a high-performance data processing package in Julia would benefit from building precise and efficiently organized code while leveraging the language's unique features.

Overview of .cursorrules prompt

The .cursorrules file provides guidelines and best practices for programming in the Julia language, particularly focused on data science and numerical computing. It outlines principles for writing concise and efficient Julia code, emphasizing the use of multiple dispatch, type systems, and functional programming. The document prescribes naming conventions, including snake_case for functions and variables and PascalCase for type definitions. It stresses the importance of documentation with docstrings and the use of tools like `@kwdef` for struct definitions. Error handling, performance optimization, and unit testing are detailed, with examples provided for each. Additionally, the file covers dependency management, code organization using modules, and maintaining thorough documentation with tools like Documenter.jl.

Optimizing Julia Language Tools .cursorrules prompt file

Optimizing Julia Language Tools .cursorrules prompt file

Optimizing Julia Language Tools .cursorrules prompt file

About .cursorrules prompt file

What you can build

Benefits

Synopsis

Overview of .cursorrules prompt

Tags

Optimizing Julia Language Tools .cursorrules prompt file

.cursorrules file Cursor AI Python FastAPI API

Python FastAPI Scalable API .cursorrules prompt file

Flask-RESTful JWT RESTX .cursorrules prompt file

Cursor AI React TypeScript Shadcn UI .cursorrules prompt file

Next.js React TypeScript .cursorrules prompt file

Python Pytest Typer .cursorrules prompt file

Next.js Tailwind CSS Obsidian Plugin .cursorrules prompt file

Next.js TypeScript Clerk Stripe Vercel Setup .cursorrules prompt file

React TypeScript Care Project .cursorrules prompt file

Elixir Code Guidelines .cursorrules prompt file

.cursorrules file Cursor AI Python FastAPI API

SvelteKit TailwindCSS TypeScript .cursorrules prompt file

JavaScript TypeScript Code Quality .cursorrules prompt file

Plasticode Telegram API .cursorrules prompt file

ES Module Node.js Guidelines .cursorrules prompt file

Cursor Tip

Here is a quick example of leveraging the .cursorrules file (sys

Cursor Tip

Cursor Tip

Cursor Tip

Create a Chrome Extension Fast: Cursor AI Tutorial

Build ChatGPT with Python: Cursor AI Tutorial Guide

Build AI Voice Notes App: Cursor AI Tutorial Guide

Cursor AI Tutorial: Easy Loading Page with Shadcn Components