Copilot

What Is It?

Line-level code analysis.

Copilot leverages data flow annotations (extensible, but starting with Clojure spec) and runtime analysis to help find problems while you're writing code. It can find many things that you would normally miss until runtime.

This leads to a system that has many of the benefits of a static type system without the same constraints. Experience a development cycle where you get better error messages, and are more protected from subtle regressions, oversights, and just plain typos while continuing to enjoy Clojure's dynamic and data-first design.

When Will it Be Available?

Copilot is close to an initial release, and is undergoing internal refinement and testing. We're very excited to release it, but also want to make sure it works well for early adopters. We expect to do a limited invite-only alpha release soon.

What's Wrong with REPL + Tests?

Nothing! We love Clojure and Clojurescript. We use them every day in production environments and find them to be great for solving the kinds of software problems we work on; however, nothing is perfect. The dynamic, concise, and non-annotated nature of Clojure leads to a number of challenges:

• There is very little "static information" to help tools find errors.
• Specs are nice, but only when you run something (tests or the program itself).
• Generative testing is hard to work with, especially in the presence of side-effects.
• It is very easy to think you're making a compatible change locally, only to find an unexpected global effect in production.

Why Not Static Types?

Those of us that have worked in statically typed languages know the benefits they bring like improved optimization, refactoring ease, and freedom from certain classes of problems. Those of us with enough experience also recognize that code using static type systems:

• Is often much larger and more complex than the problem it is trying to solve.
• Becomes increasingly hard to adapt.
• Wraps the real (simple) data of your program in incidental complexity.
• Is only free from problems that are provable statically. They do tell you something about some mistakes, but miss a lot, and cost a lot to maintain.