SciNim is an initiative to unite all scientific Nim packages under a common umbrella, and making sure they play along nicely with each other. Examples of packages we currently work on are Flambeau (a wrapper for Pytorch's backend, Libtorch) and Unchained (A fully type-safe, compile-time only units library). We have started a project at getting-started where we plan on writing getting-started tutorials for a wide variety of topics so that new users interested in Nim for science have a one-stop-shop for getting up and running. We aim to provide tutorials for both the most basic things in scientific computing like linear regression and tensor operations to more advanced topics in the different areas. Right now we are in the brainstorming process and would like to hear what you think would be useful tutorial topics to write in the future. The idea is that this should be community-contributed and that if you have something you think others would have a use for you will be able to submit a PR with your tutorial. We will also try and write about the topics we are familiar with and if we can get your suggestions it will be much easier to know what to write about and what people want to read about. :)
It's worth noting that it doesn't have to be tutorial ideas for already existing packages. It could also be ideas for tutorials on topics which doesn't yet have any packages. That would let us know that such packages are wanted and we would get a better understanding of what packages the community wants to see in the future.
Nimibook was recently released in a first version and Nimib is a perfect suite for writing tutorials and making sure they are up to date as the code examples are compiled when generating the HTML. The plan is to make use of them and write all the tutorials using them. An example can be seen on Nimibook's website .
If you have any thoughts on topics you would like to write/read about, head over to github and write some lines about it. No idea is too small to be shared! :D
If you would like to become involved in SciNim, for example contributing to a specific project, starting your own under the SciNim organization, or migrating your existing one, reach out to us on the nim-science channels on Discord/Matrix/IRC and we'll take it from there. We would very much appreciate help of any kind, even small things like finding/fixing bugs to writing docs are important for giving the users the best possible experience. Don't hesitate to get in touch with us if you have any questions.
Have a nice day!
-- The SciNim Team
What about.
1. Group Theory and RSA . Learning group theory from zero; what is it and definitions; to Euler`s phi function and Fermat's little theorem with playing Nim to build and calculate actual group structures. Then, implement RSA from scratch.
2. Grobner Basis . This is more for math students. Learning Ring theory and playing and implementing with Grobner Basis and related algorithm.
3. Some multi agents simulator? Only I have practiced is about economics, like a kind of "monetary economy modeling" stuff, but it seems fun if there is multi agents simulator library for Nim.
If there is one match your project, I may be able to help you a little.
I think Nim Notebook could benefit from the literal code style. In the current format nim book written as Nim code is the primary, and the human text is the secondary, the code
Literal code style changes priorities, the human text made the first priority and the machine code has secondary priority, I rewrite the code from example above using literal style. I think Literal Code Fromat also plays really well with the white-space nature of Nim.
You could in fact use nimib to build a binary that is able to translate a text file in the "literal code style" to a nim file, compile and run the nim file and show the results.
When I started developing nimib I was actually targeting this type of workflow (using a binary to parse another format, run and render stuff). The moment I realized I could develop nimib as a library, development went much faster and was more natural. I think this type of approach plays very well with nim syntax, not only for indentation, but also for the flexible code block syntax and usage of templates (I would not be able to replicate something like that in Python for example).
Maybe in the future a nimib binary will come to light and will be able to support such a workflow. For the moment this is not a priority of mine, but you are welcome to give it a try. :)
For general explanatory or exploratory articles/documents I agree. I write all my notes in Org mode together with ntangle.
Two examples:
https://github.com/Vindaar/ggplotnim/blob/master/recipes.org
https://github.com/Vindaar/TimepixAnalysis/blob/master/Doc/other/axionWithGasPhase.org
But for the purpose of what the getting-started repository is trying to do, I think nimib is a great fit. Not only is it only using Nim tools instead of relying outside tooling, but more importantly: the point is helping people get into Nim for scientific computing. So by definition the code is the priority.
It doesn't make sense to do Literate Code format as a separate project. Because it should have full support for all the standard Nim tools like nim r notebook.lnim and VSCode. Or don't do it at all.
I think popularity of JUpyter Notebook and ObservableHQ and Markdown formats are demonstrating quite the opposite, that code is not the king of the show :).
And sacrificing the ergonomics of the tool (Notebook) only to make it a bit easier for beginners to start, seems like a wrong way for long term success.
Almost no one reads as / starts working from some random file format, be it Org, Markdown, etc. For instance the number of times people have read and used the Org files of notes I sent people over the PDF is.... probably 0.
In the end then it doesn't make a difference whether the actual original document is written as source code for a language, in a text format with code snippets like Org etc.
You might be getting the wrong impression from the mini plotting example, because it's essentially only code and barely any words. But that's only because it's more of a placeholder and less of a proper getting started guide.
It feels like we are talking about two separate things here. NimiBook isn't an alternative to Jupyter Notebooks (yet) but rather to mdBook and Gitbook, ie it generates static websites. Nimib is all about the generation of these HTML documents from Nim code. The reason we don't see this in a lot of other languages may simply be that they aren't flexible enough to allow it like Nim is. Here you have a more comprehensive example of what Nimib is like using and here is the final website.
And sacrificing the ergonomics of the tool (Notebook) only to make it a bit easier for beginners to start, seems like a wrong way for long term success.
I don't see where you get the "make it a bit easier for beginners" from. The beginners will just see the final website, not the source code that generated it so it doesn't matter what tools we use to generate the website for the reader. Except that with Nimib we can guarantee that the code on the website runs as of the latest update, and this is where we can get the long-term success as code doesn't rot away ;)
For Tutorial ideas. I think the best would be to replicate the most popular python introductionary notebooks. With lots of visuals and simple math. Like Titanic Stats or something like that. It's easier for people to learn when they already know some part of new thing. And those pyton tutorials seems to be well known.
Good idea :D Would you mind writing a comment in the issue mentioning it and maybe some of the popular introductory notebooks you had in mind?
Maybe I'm not clear what I ment by Literate Nim Format. It's like plain Nim code, with the only difference that all the code is indented by +2 spaces and whatever is not intented by +2 spaces are threated as comments/text. Like Nim source filters with 2 spaces " " as metaChar.
So it's has all the same advantages and power as the plain nim code, and additionaally it's visually more appealing with the text standing out, and gets auto-rendered on GitHub and other Markdown like renderers (without plotted charts but still rendered). And (ideally) full VSCode support.
Would you mind writing a comment in the issue mentioning it and maybe some of the popular introductory notebooks you had in mind?
Added.
Maybe I'm not clear what I ment by Literate Nim Format. It's like plain Nim code, with the only difference that all the code is indented by +2 spaces and whatever is not intented by +2 spaces are threated as comments/text. Like Nim source filters with 2 spaces as metaChar.
Thank you for the explanation, it's much clearer now! :)
So it's has all the same advantages and power as the plain nim code.
I disagree very much on this point, literate code format doesn't have the same advantages and power as writing it in Nim code. For one, you can't use Nim-code to modify or add text using Literate code format which is possible in Nimib. For example the Table of Contents example in the cheatsheets example. Here it's defined and (here is it used)[https://github.com/pietroppeter/nimib/blob/12326295444970cbbf18b5872129d2cfb9755700/docs/cheatsheet.nim#L84]. Literate code format wouldn't be able to do this without support for it in the parser while Nimib can handle it one it's own because it's so flexible and powerful. And this is just a simple example, imagine what else you could use Nim's meta-programming capabilities for when constructing documents. This is the main advantage of Nimib in my opinion, that we can construct the document using Nim code and that we can use Nim code to remove repetitive task (like the nbSection in the link above). This isn't possible in literate code format as the text by definition is static and the code is just code and can't affect how the document functions.
and additionaally it's visually more appealing with the text standing out, and gets auto-rendered on GitHub and other Markdown like renderers (without plotted charts but still rendered). And (ideally, some day) full VSCode support.
You have a fair point as long as the format you use is supported by all these places. I'm working on a plugin for VSCode that will highlight the markdown in Nimib documents atm so one could say we already have VSCode support ;) (almost, I haven't finished it yet)
Added.
Thank you very much! :D