To Do

In no particular order, here are some of the pending development tasks.

Implement printf

The format function in core.clj depends on Java’s String.format, a printf-style formatter. There is no BCL equivalent, so we will have to implement it.

This has been partially written. Still awaiting completion:

• extend float spec to BigDecimal arguments
• extend float spec to System.Decimal
• implement HexFloat spec
• implement grouping for General Float spec
• implement grouping for integer spec / BigInteger arguments

Loading of standard environment

There are several .clj files that are part of the standard environment of ClojureJVM that we have not translated yet.

• clojure/xml.clj
  • The implementation relies extensively on SAX parsers as defined in org.xml.sax and javax.xml.parsers. This will require non-trivial rewriting to make it rely on BCL equivalents.
• clojure.inspector.clj
  • Swing doesn’t swing it in CLR-land. This will need to be rewritten completely to make it work with WinForms or WPF.

Proxy and genclass

• Implement bean (in core_proxy.clj).
• Test proxy implementation against
  • explicit interface method implementation
  • generics wherever

Testing

There are more than 500 unit tests for the basic runtime libraries in the Clojure.Tests project. There are many gaps and omissions.

There should be a set of tests developed for compiler functionality. See the compiler tests in IronPython and IronRuby to get a sense of what should be done.

Finish implementing core.clj

Most of core.clj has been implemented. Those things not implemented typically had some problems.

seque

Depends on java.util.concurrent.BlockingQueue and .LinkedBlockingQueue.

resultset-seq

Works on instances of java.sql.ResultSet. I would argue this should not be in the core. What class should this work against in ADO.NET land?

Optimize, optimize, optimize

Premature optimization may be a sin. That is not our problem here. ClojureCLR must be speeded up. The basic libraries seem to run just fine. For example, the reading time (no evaluation/compilation) for core.clj is close to the same. Improvements here will come at the expense of fine-grained analysis of the code generated by the compiler and perhaps an examination of some of the decisions made in implementing the current compiler.

Developing a set of microbenchmarks in Clojure code would be nice for experimenting with compiler variations and for comparing against the JVM version.

clojure-contrib

The various libraries in clojure-contrib should be loaded and tested here. Because those libraries often have JVM dependencies built in, a long-term solution requires a mechanism for maintaining dual JVM/CLR-interop in CLJ code.

An important first step here is just to run the test-is tests.

Mono

Test under Mono. (We need to get rid of the vjslib dependency first.)

Reflection warnings

On a related note, systematically run through all the reflection warnings generated while compiling the bootstrap files core.clj, etc. (Compare against what the Java version generates.)