The next step for Typed Clojure is Gradual Typing. Gradual typing takes interlanguage interoperability seriously, and is designed to protect the invariants of statically typed code at runtime.
Typed Clojure will be enhanced to
- CONTAIN ill-typed foreign code before it can compromise typed code,
- ENFORCE annotations for foreign code at runtime, and
- PROTECT typed code from foreign callers with runtime contracts.
![]()
Programmers can assume static invariants can never be broken. This is exactly what I want from a type system!
If you agree, please fund this project! Check out the perks and also share with your friends!
About me
My name is Ambrose Bonnaire-Sergeant, I'm the creator and maintainer of Typed Clojure, the optional type system for Clojure. Typed Clojure has been the focus of my working life for the last 3 years:
- Typed Clojure was the subject of my undergraduate dissertation in 2012,
- I participated as a Google Summer of Code student with Typed Clojure in 2012 and 2013,
- In 2013 I ran a successful crowdfunding campaign that supporting full-time development on Typed Clojure for a year, resulting in extensive improvements,
- I mentored 2 GSoC students working on Typed Clojure in 2014,
- I will similarly mentor 2 GSoC students in 2015,
- I'm currently a PhD student at Indiana University Bloomington working on Typed Clojure.
I have a long term commitment to Typed Clojure and have big plans for it.
More about Gradual Typing
Gradual typing addresses issues of interlanguage interaction by inserting runtime checks at key places to ensure typed code is always protected. The details of how a gradual typing system is implemented are technical, but the result should have certain properties:
-
porting untyped code to typed should not change its semantic behaviour, except for throwing more runtime errors (corresponding to contract violations).
- gradually typing an area of code should have a localised performance cost. Your entire code base shouldn't have to pay for a section of gradually typed code.
-
typed code should be exported to untyped code in a way that protects the typed code from ill-typed tampering at runtime
-
importing untyped code to typed code should enforce the untyped's expected static type at runtime.
What's done so far?
I have developed Clojure's first statically typed REPL that integrates with core.typed.
This is the first opportunity for core.typed to intercept the compilation of Clojure code, opening the door to automatic runtime contract insertion and other type-based optimisations (like adding type hints).
You can try this in the `repl` branch of core.typed.
How you can help
tldr; Fund and share.
This campaign represents an opportunity for you to support my work on Typed Clojure. Please contribute to the funding total, and/or share this campaign on the usual channels.
Equivalently, you can help me work through the backlog of issues and patches waiting on the core.typed JIRA.
Where are the perks?
tldr; Still working on 2013 perks.
I still have perks I owe from my last campaign that I will release for free. Everyone will have access to a tutorial series for core.typed. See example videos below.
What happens if this campaign does not raise all funds?
tldr; It will take longer to complete this project.
I have activated partial funding on Indiegogo, which means I will keep any funds (however, I will pay more fees to Indiegogo).
With respect to the project itself: it will still get done. This is my job and research direction which will be completed regardless of the result of this campaign.
This campaign exists for financial reasons (see below) and I may need to find a part time job over the summer while in Australia, which means I will have less time to dedicate to this project.
Timeline
This is will change as the project evolves.
Month 1: May 15th
- Formulate gradually typed calculus with polymorphic functions that respects the gradual guarantee
- Prototype solution to exporting typed vars with contracts
- Import untyped vars to typed
- Safely export typed vars
- Implement function/datatype casts
- [x] By May 22nd: 20-30 minute 2nd video tutorial (https://www.youtube.com/watch?v=DfYsjYBo3gA)
- [ ] By May 29th: 3rd video tutorial
- [ ] By June 5th: 4th video tutorial
- [ ] By June 12th: 5th video tutorial
Month 2: June 12th
- Extending typed/untyped protocols with typed/untyped datatypes
- Extending typed/untyped multimethods
- Implement Automatic type hint insertion
- [ ] By June 19th: 6th video tutorial
- [ ] By June 26th: 7th video tutorial
- [ ] By July 3rd: 8th video tutorial
- [ ] By July 10th: 9th video tutorial
Month 3: July 10th
(We'll see what's left and what new problems I've uncovered.)
- [ ] By July 17th: 10th video tutorial
End (Back to Uni): August 14th
What else will you be doing this summer?
Sam Tobin-Hochstadt has employed me to continue my research on Typed Clojure this summer. This project is a subset of the work we expect to complete.
I am also thrilled to be mentoring two students working on Typed Clojure for Google Summer of Code 2015.
I'm also available for Typed Clojure contracting work. Please contact me if you want something done in Typed Clojure.
Why is your target $10,000 for 3 months work?
tldr; So I can sustainably continue researching Typed Clojure.
If I earn US$35k this past academic year, I will be in good shape.
As a graduate Research Assistant I earnt US$19k this academic year, and I am grateful Sam Tobin-Hochstadt has continued to employ me this summer (US$3.8k). Indiana University also pays for my tuition.
Maintaining simultaneous lives in Australia and America is simply expensive. For the first time in my life I've had to borrow money from my parents, who have been very supportive, but that is unsustainable and simply unacceptable to me.
I cannot make supplementary income while in the US for visa reasons, so this summer in Australia is a valuable opportunity to replenish my funds. My visa restrictions are the reason I chose Indiegogo over a more sustainable model like Patreon.
I have had an amazing year educationally and socially at Indiana University Bloomington and I will do what I can I stay here, and this campaign is one way for me to ensure I have the financial flexibility to stay there.
You still owe me perks from the 2013 campaign!
tldr; They'll be done this summer.
I have cut back on perks this year for this very reason.
I will honour all previous perks. This summer I will finish the tutorial series of videos sponsored by my most generous funders. These will be released for free on YouTube.
One is already up.
My series of user group talks has been very successful, but I still have over 10 talks to give out of 20. If you bought a User Group Talk perk, expect an email from me soon to schedule a talk in the next year. I'm open to travel if you can organise the funds; I have already given several talks in person and they are always tons of fun.
Here's an example of how much fun we have:
My company wants to fund you, but we cannot pay individuals via Indiegogo
Please send me a message and we might be able to work it out.
What's *next* next for Typed Clojure?
The next big project after gradual typing is supporting transducers.
The big problem is Typed Clojure's support for local type inference, which currently forces users to annotate all anonymous function arguments and instantiate polymorphic functions applied to other polymorphic functions.
There are known solutions to some of these issues via CDuce, an XML processing language with union, intersection and negation types.
