Mastering Nim: A complete guide to the programming language

Recently, a handful of new programming languages have arisen that are poised to potentially displace most high-performance programming currently done in C and C++. These include recent languages such as especially Rust, Zig, Jai, Odin, V, and Pony. There's also Julia, although that is more data science oriented and has some platform-independence problems. Anyway though, among these new languages there is also Nim (the subject of this book, written by the language's original creator). I encountered Nim once years ago but didn't pay much attention to it because (like many people) I did not truly understand what its awesome value proposition was and how fantastic of a language it is. I saw it had an (actually entirely optional) garbage collector and that the first book written for it spent a lot of time on web dev stuff, so I immediately dismissed its viability (very prematurely though, as it turns out). I've been interested in Rust for a few years now and tried it out a bunch, and have also briefly messed around with Zig. I've also explored using dozens of other languages over the years, some professionally for years and some only briefly to play with them, including examples such as: C, C++, C#, Java, Python, Lua, Lisp, Scheme, Racket, Factor, Prolog, and various others. I've also used some specialized languages like GLSL, HLSL, and Cg. I've worked professionally in the game industry too, both AAA and indie, so I understand why performance matters and some of the things to look for in evaluating it. However, once I started using Nim it has fast become my overall favorite new language and I am excited to do my next project using it! Nim easily seems like the best overall language of the recent generation of new languages, at least when you ignore Rust's ecosystem and community size. Nim is growing fast though, with nearly 2000 community packages already available despite only reaching version 1.0 in 2019! Rust in contrast reached version 1.0 in 2015 and so Nim is a much younger language. Nim is the most free of needless tedium and busywork of any of these languages and feels even easier to learn and to use than Python, and yet still has performance that is roughly on par with C or C++. It's optional garbage collector comes in several different variants and the system is designed with hard real-time requirements in mind. You can specify how much time it is allowed to run for example. Also, they've recently created two new garbage collection modes (ARC and ORC) which basically behave the same as C++ RAII does and thus makes the GC largely a non-issue. Plus, you can manage memory completely manually in Nim if you want to and its C interop is great. So, the GC "problem" that people assume coming from Rust mostly isn't even a practical problem in Nim. People are making assumptions about that based on their experiences with other languages that don't really apply to Nim (which seems to be the most common reason why people dismiss Nim: invalid assumptions based on subconscious experiences from working with other languages, i.e. basically language feature stereotyping). In reality, ignoring ecosystem/community size differences, Nim seems like it would usually be a better language to use than Rust for most programs. Nim's community and package collection nonetheless is still larger than most of the other competing next-gen languages (except for Rust mostly), so Nim actually seems to have a bright future! Nim even has a (currently experimental) borrow checker of its own that can be enabled with the {.experimental: "views".} pragma, and made more effective by also using the {.experimental: "strictFuncs".} pragma. Thus, Nim may one day have most of the borrow checking features of Rust too, as an optional rather than unavoidable (and often painful) feature. The lack of syntactic clutter and the ease of use and clarity of most of its design is honestly refreshing. One does not truly appreciate how much the syntactical noise gets in your way in other languages until you try something like Nim or Python. It makes all of your work both easier and more expressive, and yet Nim still runs about as fast as most C or C++ code, despite being easier than Python. Nim's metaprogramming is also similar to what's available in Lisp, Scheme, or Racket, except that it requires the resulting syntax to be Python-like, which is honestly a good thing when you consider how much harder to read the nested parentheses or DSL language mangling in Lisp family languages often are compared to Python-like languages. Nim is the closest to a "best of all worlds" programming language I've found yet! I recommend you try it! Don't let the lackluster (as of July 2022) book cover here fool you! Nim is a fantastic language! It is already usable for production for high performance game dev and for many other uses cases. I did find a handful of typos (~ 7 of them) though and also had a technical issue getting the first program examples (the pixel graphics ones) to run. Speaking of which... IMPORTANT: On Windows, if you get an error when trying to run the pixel drawing examples early in the book then you probably need to download SDL2.dll and SDL2_tff.dll and place them in the same directory as your Nim code. Otherwise, the code might not run. The package for the pixel drawing the author used doesn't seem to always get all the dependencies right. It probably has an error in its package specs somewhere (as of July 2022). The "drawText" command also doesn't respond to the x coordinate apparently.

Got this because I'm learning Nim after years of programming in other languages, C#, Python, Go, JavaScript and so on. I've not yet finished the book, but I'll detail what I've noticed thus far. The first few chapters are short and sweet. There is not a lot of hand holding, this book assumes you have some familiarity with programming languages, if you've never ran "npm install x" or "pip install x" or similar commands for installing packages in another language, you might want to do further research before approaching this book. If you're comfortable kind of just filling in the "gaps" then this book is perfectly fine and great. Also the book is physically small, it is not super long or wide, I would say it is similar in size to a 7" tablet or a Kindle device, but a little thicker than a Kindle or tablet, maybe an inch? It is under 300 pages of code and explanations. It might not be for everyone, but for my purpose of getting familiar with Nim even when I'm nowhere near a computer I find it pretty effective. This is the first edition of the book by the author so it has some rough edges, and I intend to note any typos or grammatical errors to share with the author, but I have not yet ran into anything insane that stops me from progressing. The Nim community also has a rich set of options for those seeking help, everything from a forum to a Discord server, where you can find the author if totally necessary and if no one else is able to help. If you're comfortable with all of the above, and you want to learn Nim. I couldn't recommend this book enough. Otherwise, I highly recommend you try the official documentation which is free.

The electronic version has formatting errors. Some special characters are wrongly substituted what makes some paragraphs hard to read/understand - the online free manual does not contain those mistakes. In general, the book is not the best book to learn a programming language. Unfortunately, there does not seem not to be anything better. It (over) focuses on EBNF details in some parts instead of making sure that the examples are better structured and explained: sometimes an example illustrates some concept introduced in the preceding paragraph, yet the author does not bother to explain the code any further leaving it without comment (not all examples are like that, but there enough of some important ones that are missing good description). Bjarne Stroustrup in his C++ book does a way better job: examples are exhaustive and well connected with the text. I am not sure if the printed book has the same encoding problems. I am a bit hesitant to order it (price!!!! - the price of this book is a bit hard to justify - the above mentioned monumental C++ Programming Language, 4th Edition by Bjarne Stroustrup has almost the same price). I still recommended the book, yet I think it is a lost opportunity.

I stumbled upon Nim while I was looking for a statically compiled, easy to learn programming language which compiles to machine code. I think Nim is a nice language (similar to Python), which can be a useful addition to one's programming toolbox. I wish Nim could allow for the writing of better functional programming with proper constructs for pattern matching and variable binding, e.g. let [first | rest] = [1, 2, 3], and possibly a pipe operator a la Elixir or F#. Having said that, unlike most programming books I've encountered, this one uses a color theme which improves comprehension, and allows one to visually identify language concepts more easily. More programming books should follow this. In addition, the book is written by no other than the creator of the language himself, Andreas Rumpf. Thank you Andreas for giving us Nim. P.S. If you're on a M1/M2 Mac, you need to use brew to install sdl2 and sdl2_ttf to be able to successfully compile the examples, as the nimble pixels package depends on them.

This is a good book to explore the mechanics of Nim. It is severely hampered, however, by the lack of a useful index. This is by no means a reference manual, more of a "how I did this".

This book is concise, incredibly clear, the page layout is stunning in its beauty, and the content immediately useful. Wonderful job. (and i've been programming professionally since 1983 or so, started quite young, have used many languages including compiler internals....this book is just excellent) Edit days later : nim is compiling just fine on an M1 Mac and I've tested that, despite what another reviewer wrote and gave a 1 star review for, which is unrelated to the book, but to the reviewer's computer being misconfigured.

Despite what they tell you this book relies on libraries that have been nonfunctional on Arm macs for 3 years. Only useful to some people. Mine also came with some gross greasy handprints on the cover. What a shame. I really wanted to like this language but this book is such a poor front doorsman and there really isn't much else to learn from. Nim has a new user contempt problem.

I got this book and was excited to start to learn the Nim language only to find that the very first code example fails to compile and run on my laptop (an M1 MAC). I am disappointed because I started underlining in the book (before I realized it will not work on my laptop) and so cannot return it now.

As the author, the book is really laconic and it’s more a cookbook than a book to learn nom

The Nim programming language is a language that lately has been gaining some popularity due to its particular mix of features that come from different languages like Python, Modula-2 and Lisp. The particular thing that interests me the most about the language is how it provides structural amenities for high-level and low-level programming which is a win-win for somebody like me who is used to high-level programming and want to start digging into systems programming. ### The Good ### - This book is written by the original creator and designer of the Nim programming language and because of that, in certain parts of this book he gives you invaluable information about the how/what/when of certain features of the language. He also explores quite deep into the implementation of the language (which may be useless if you're just a regular programmer like me but it's nice to know how Nim works under the hood). - If we consider this book to be a manual, it will teach you all the basics (and many advanced things as well) of the language that will allow you to write Nim code without hesitation. - Most of the examples of this book are really helpful for you to understand the feature they illustrate. - Code blocks are colorized (for a printed book this is really nice). - Part III: Masting Macros is an awesome tutorial about the macro system of Nim. ### The Meh ### - A lot of the info is just copy-pasted from the online manual (however the book also implements some unique examples). - The explanations of some features are quite short and do not provide examples, or the examples are too complex (or simple) to illustrate the usability of certain features (Methods and Dynamic Dispatching, Effect System...). You still can figure it out the usability by playing with the provided code but it's certainly something it could be better. ### The Bad ### - Concepts do not appear in this book (I'm not sure if that's the only Nim feature that is not in the content of this book, so please be aware that there might be more useful information about the basics of the language that is not provided). - It does not contain information about how to write idiomatic Nim code. You just have to rely on community docs.

It feels like the author wrote 35-40 pages of a book.. then got tired and pasted in the publicly available manual. Especially bad is the index (first-occurence) of a small subset. I think the author ows me a book.

省略が多く、初心者向きではない。

Simply the best book of Nim Lang I've been reading.