Hi,
Let me start a place to list project ideas which might be useful, helpful or just cool. Please feel free to comment/extend/criticize.
If you wanted to add project ideas, then please start with a [title] to help future references.
Thanks, Peter
[lockfree data strucutres] Since the main target of Nim is C, let me forget JS for this project. There are some lockfree libraries in C/C++, which are usually doing something simple: for example Boost has a lockfree queue and stack. These are fast. Most languages don't have lockfree structures, and Nim could have one by wrapping an existing solution. I really don't know the quality of these libraries, sounds like a research project. Nim as a system programming language could benefit these implementations.
[web game] There should be a Nim JS library where the whole browser screen is one large canvas, it would have WebGL, keyboard, mouse and networking support. It should be very simple, also extendable (without any limitation), and the example codes should be very short. There should be a webserver part (to save stats, and obviously for multiplayer support) which compiles to C. Since frontend and backend would be in the same language, you could easily share objects (via json with sharing the code). People use PyGame, because the language is nice. They could use Nim as well :)
[continuation] Let's imagine that we are in a webserver's URL check. We handle "index.html" and "favicon.png", the rest of the code is not yet implemented. We put there stop. If the code reaches stop, then the program would pause. At this point all the local parameters are printed (like echo locals()). You could play with a REPL here, and also finish the code in your favorite editor, save it. Your webserver program would detect that its source file has been saved, it would recompile it and use it (technically the new part would go into a function to a dll/so file, which would be loaded and called with the parameters returned by locals()). Therefore the code could be written while it is running (Lisp feeling). I believe that this can be done currently in a library with macros without any specific compiler support.
[bigint library] Nim should have bigint type with arbitrary size. It would behave the same way as it does in Clojure: any operation between int and bigint would result a bigint. We should implement everything which is available for int (like +-, isPowerOfTwo, echo) for bigints as well.
[combination, permutation, etc.] Like in Python's itertools library, we should have all the basic subset operations, like combinations([1,2,3], 2) == @[[1,2], [1,3], [2,3]]. This is my longterm goal (after working on sequtils and an iterator library), because all these functions should work on iterators as well, and return iterators (just like in Python).
about [bigint library]:
I would like to see Nim get more adoption in the scientific computing world (think what Julia is targeting). Some things I would like to see are:
[linear algebra] I would like Nim to get its own Numpy. I have already started this effort but any contribution is well appreciated!
[neural networks] based on that, it would be really nice to get something like Torch but somewhat more type-safe. I may try something in the future, but I cannot promise anything. If anyone wants to try something, I would be happy to add the necessary pieces to linalg to support it.
[optimization algorithms] somewhat needed for the neural networks. Something like the optim package for Torch
[clustering] some collection of clustering algorithms. Even a single-threaded implementations of the most common ones based on the descriptions on wikipedia would be great!
[other machine learning stuff] really, there is a lot to do, and the basic algorithms are not that hard. Random forest, SVM (at least a high-level interface over libsvm)...
Outside the scientific applications I would like to see:
[some DSL for parser combinators] Ideally something like parboiled or petit parser for packrat parsing
[pattern matching à la ML] I have started a little effort with patty but there is still much work to do
[actor model] something like Akka for the JVM. Actors are a very simple and effective concurrency model and it would be great to be able to use them in Nim
I could also add
[clients for popular messaging systems/queues] I would be particularly interested in Kafka, ZeroMQ and Nanomsg. I am aware that ZeroMQ is already available, and both Kafka and Nanomsg have C libraries so binding to them is pretty trivial. But these are all designed with C in mind - so clients have to manually allocate and delete messages - do not make use the Nim concurrency features and are in general a hassle because they are managed with CMake, autotools and so on. I would be great to have native Nim implementations for these protocols, so that adding the appropriate line in the Nimble file is all that is required to use them, and libraries make use of Nim features such as memory management and spawn as expected.
[serialization formats] it would be nice to interoperate with other languages using serialization formats such as Thrift, Protobuf, Cap'n Proto, FlatBuffers and so on
about [serialization formats]:
[Intrusive Lists]
lists.nim is overdesigned: Often I already have an object with direct prev and next pointers. Appending and prepending etc should just be templates operating on something which has prev and/or next.
[Big Data]
Numpy has been mentioned, so also add the equivalent to pandas, and something equivalent to mathplotlib
About [bigint library]: @def: So there are several solutions: either a slower version in Nim, or a faster version with GMP. I believe that we should have both of these as part of the standard library with a common interface. The Nim version should be the default (because it runs with C and JS without any dependency), and the GMP version could be enabled by a command line switch. We could have common tests. What do you think?
About machine learning, data mining, data plotting, scientific calculation related topics: These sounds like very difficult topics. All the famous libraries I use (ggplot, data.table, pandas) are updated within a week. Their codes were evolved by hundreds of bug reports. I think that Nim should either start with something simple (e.g. write some good plugins to existing systems), or work more on the basics (better sequtils, channels support, memory sharing patterns between threads, better REPL, compile to CUDA, clustering, etc.).