Jira Is Turing-Complete
This article proves that Atlassian's Jira, a ubiquitous project management tool, is Turing-complete by implementing a Minsky machine using its automation features. The proof involves mapping registers to issue counts and program states to Epic statuses, leveraging issue creation/deletion and conditional rules. Hacker News commenters widely embrace this finding with dark humor, often linking the theoretical complexity to the practical frustrations of working with Jira.
The Lowdown
Nicolas Seriot's article provides a definitive proof that Jira, the much-maligned project-tracking tool, is Turing-complete. This confirms a long-standing piece of engineering folklore by constructing a Minsky register machine within Jira's automation framework, complete with setup instructions and execution traces.
The proof hinges on the following mappings and implementations:
- Computational Model: A Minsky register machine, which requires two unbounded counters and basic increment/decrement operations with conditional branching, is used as the target for reduction.
- Jira Mapping: Registers are represented by the count of linked issues of specific types (e.g., Bugs for Register A, Tasks for Register B). The program counter is encoded by the status of a single Epic issue.
- Instruction Dispatch: Jira Automation rules, one per instruction state, inspect linked issue counts and trigger transitions between the Epic's statuses, effectively controlling program flow.
- Operations: 'Increment' (INC) and 'Decrement' (DEC) operations are implemented by creating or deleting linked issues of the corresponding type. Conditional branching (
if r == 0 goto S else goto S') is achieved using JQL-conditioned rules. - Example Implementation: A simple addition program (A + B) is demonstrated, showing how an Epic transitions through states, manipulating linked Bugs and Tasks, to achieve the sum.
- Fibonacci Sequence: A more complex Fibonacci sequence generator is outlined, leveraging Jira's 'Convert Issue Type' feature for more compact state transitions, though requiring human re-triggering due to Jira Cloud's chain-depth caps.
Ultimately, the article concludes that despite finite system quotas, Jira's automation language, under standard conventions, possesses the computational power of a Turing machine. This implies that complex Jira automations are not just 'like' programs, but are, in fact, programs.
The Gossip
Jira's Janky Journey to Completeness
Many commenters express a lack of surprise at Jira's Turing-completeness, often attributing it to the tool's perceived complexity and awful user experience. Comparisons are made to low-level programming like assembly or Brainfuck, highlighting the frustration of working with its automation tools. There's a strong sentiment that Jira's theoretical power aligns with its practical difficulties.
Turing Test of Tooling
The discussion branches into whether all workflow and orchestration engines are inherently Turing-complete. Some argue yes, stating it's their fundamental purpose, while others debate the necessity of features like infinite counters or unbounded execution to truly achieve Turing-completeness, questioning whether Jira's reliance on human re-triggering for infinite loops detracts from the pure theoretical claim. The theoretical underpinnings are compared with practical limitations and design choices of such systems.
Automating Away the Awkwardness
A significant thread discusses the practical implications of Jira's API and automation capabilities. Some users describe using scripts and external tools to automate Jira tasks, acknowledging the difficulty due to inconsistent APIs and 'fractal shit snowflakes' of custom configurations. However, they also attest to the high value and 'cover your ass' potential of such automations, sometimes even using them to a 'malicious extent' to streamline their own work or manage expectations.