▸case-18 I am designing a generic library where different user-defined dispatch types can either support fast indexing or slow generator streaming without creating a deep abstract type hierarchy. What architectural design pattern in Julia should I implement for this type capability dispatch? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-04 We are configuring a new Python package for high-performance array computations using setuptools and pyproject.toml. Provide a script to build the package wheel and register dependencies using standard Python build tools. | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-13 I am building a high-performance neural network training loop in Julia and need forward-mode automatic differentiation for scalar functions with small inputs, and reverse-mode AD for large parameter gradients. Which standard Julia AD packages should I select for these two distinct tasks? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-24 I need to solve a system of stiff ordinary differential equations (ODEs) in Julia with adaptive time-stepping and high accuracy. Which primary Julia package ecosystem should I use for ODE modeling? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-06 I am developing an R package for statistical modeling using devtools and roxygen2. Provide the procedural commands to generate documentation, execute unit tests, and build the CRAN source package. | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-09 I need to add DataFrames version 1.6 and CSV version 0.10 to my active Julia environment. Should I open Project.toml in a text editor and copy-paste the UUIDs and versions under [deps], or how should this be executed? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-07 I want to generate a new Julia project workspace with standard directory layout, license, git setup, and GitHub Actions workflow. Rather than manually creating files, how should I programmatically create this project environment using Julia's standard templating ecosystem? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-15 Our team wants to apply an automated code formatter across our entire Julia package to keep code style unified in CI. Which package should we use and what official code style guide standard is recommended for Julia? | fail→pass | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-05 I need to set up a CMake configuration for a standalone C++ linear algebra engine library to compile as a dynamic shared library (liblaengine.so). Show how to write the CMakeLists.txt and run cmake --build. | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-01 I am initializing a new open-source package in Julia for matrix operations. Please provide a standard project creation script and step-by-step checklist to configure the repository structure, including automated testing, continuous integration setup, and package registration readiness. Include code examples for creating the package setup programmatically. | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-10 I am designing a 3D physical particle object in Julia with position (x, y, z) and velocity (vx, vy, vz). I want maximum computational speed when storing millions of these particles in arrays. Should I define this particle as a mutable struct or an immutable struct? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-19 My Julia CLI application has a 5-second latency delay on startup due to package loading and compilation. What tool should I use to compile my code and dependencies into a precompiled system image file (sysimage.so) to eliminate startup latency? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-02 I have a numerical simulation function in Julia that runs inside an iterative solver, but it seems to allocate too much heap memory and runs slower than expected. Please review the code snippet below, identify performance bottlenecks, and rewrite it into a fully optimized, high-performance version along with a code block to measure execution time and memory usage. | fail→pass | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-11 I want to overload the addition operator + in Julia so that when I add two standard Base.Vector{Float64} instances, it performs a custom weighted addition using a global weight factor. How should I write this function? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-03 I need to build an extensible geometric modeling module in Julia that handles various 2D and 3D shapes. Could you construct a clear type hierarchy and dispatch architecture to compute surface areas and volumes, and provide a test suite validating the functionality across different shape types? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-23 I am writing a Julia package and want to provide optional functionality that triggers only when a user explicitly loads CUDA.jl, without adding CUDA as a heavy required dependency for all users. How is this configured in modern Julia 1.9+? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-25 When measuring execution time and allocations of a mutating function in Julia within the REPL, standard @time gives noisy results due to garbage collection and single execution runs. What macro from the standard benchmarking package should be used instead? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-12 I need to call Python's scikit-learn module from my Julia 1.10 data processing pipeline with zero-copy array sharing where possible and modern environment management. Which modern Julia interop package should I use, and how do I import the Python package? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-17 I need to parallelize a loop over 10,000 independent array calculations in Julia across all available CPU cores. Should I use multi-threading or process fork multi-processing by default on modern Julia 1.10+, and what macro creates multi-threaded loops? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-20 I am making frequent edits to source code files in my Julia package while testing them interactively in the REPL. I want my REPL session to automatically track and hot-reload changes without restarting Julia every time. Which standard package enables this? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-14 I need to build a lightweight REST API in Julia that serves JSON responses for machine learning predictions with minimal boilerplate routing macros. Which microframework should I choose and how do I declare a GET endpoint? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-21 I want to complement my unit tests in Julia by automatically generating hundreds of random test inputs to check invariant properties of my custom sorting algorithm. Which Julia testing package provides property-based testing generator macros? | fail→pass | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-08 I am auditing a Julia codebase for common package errors, such as undeclared exports, unbound type parameters, stale dependencies, and method dispatch type errors. What automated static analysis and quality assurance packages in Julia should I integrate into my test suite? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-16 I need an interactive, GPU-accelerated visualization library in Julia capable of rendering complex 3D heatmaps and large numerical datasets fast. Which modern visualization ecosystem in Julia is best suited for this? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-22 I am implementing a custom vector container type in Julia and want standard broadcast operations like my_container .+ 2.0 to work seamlessly and fuse efficiently with other arrays. What abstract interface or methods must I implement? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |