Mastering Nim, 2nd edition

How is it for data exploration? Can you run things in a repl?

> The Datamancer data frame library is incredibly robust.

Thank you for the kind words! :) Especially given that it's a one-man side-project always makes me a bit worried people will stumble over all sorts of issues.

Based. Glad there's a refuge for sane developers that are tired of the long march of Woke destroying so many other language.

I think Nim is great for small CLIs. Some examples are over at: https://github.com/c-blake/bu . To quantify "small", using tools themselves in bu/ (and Zsh *):

    wc -l --total=never **.nim|cols 1|cstats ms q.05 q.95
    75.5 +- 5.7,22.5,175.25

So, around 1..2 pages for a 70-row terminal window, with a 5th & 95th Parzen interpolated quantiles of 22.5 and 175.25 lines.

I was considering learning Nim. Then I found out about its partial case insensitivity and ignoring of underscores in identifiers. And that was the end of my interest in Nim.

Its greatest strength at present, and for a long while, has been serving as an “expert’s tool”.

If you want to do systems programming with less hassles than C/++ (you understand them well), you appreciate the limits and pitfalls of AMM (and you don’t want/need Rust’s borrow checker), and you’re into metaprogramming, well then Nim is a great tool for your toolbox.

It can also serve newcomers to programming decently well and enables DSLs such as Enu ( http://getenu.com/ ). But it doesn’t take too long reading the Nim Manual and std lib docs to realize that a big focus is putting a power tool into the hands of developers who already understand the ins and outs of systems programming.

This is all, of course, my personal take on it, other Nim users may disagree.

The big weakness now is the transition to 2.0 and all the old docs floating around that are obsolete. It's hard to find info on what the new idiomatic approach is for things that have changed. I had to port some pre-1.0 code a little while back and was puzzled for a bit about resolving various (justified) deprecation warnings.

because nim is not a c replacement, nim is more in the go or d python replacement replacement , meaning, in the compiled languages that want to replace python category

zig and rust are the real c replacement

Yes - thanks. Submitted title was just "The Secret of Nim", which HN's software shortened to just "Nim"

Thank you. A book like this choosing an image of "mountains" that is evocative of staring up at a naked woman's body is a stunning, poor choice.

Choices like this could alienate a large number of potential Nim programmers, and make me question the tone and nature of the community.

Implied is literally the opposite of explicit

had to go back b/c I didn't see it the first time, now it is quite evident

how intentional I will let the crowd decide

I think you mean “female nude” not “explicit” here.

They aren't synonyms; “implied explicit” is an oxymoron, “implied female nude” is not. (Thouugh really, “suggestive of” or “evocative of” is probably more accurate than “implied” here, too.)

Is this a joke?

I knew I was not the only one. It is ... sus.

Ironic that a statement about an ambiguous image that might be misinterpreted to be something it is not has spurred such a rousing discussion about the ambiguity of the comment itself, which may be misinterpreted to mean something it is not saying.

Bruh!! You've stirred my inner poet.

Ode to my most beautiful Goddess Nim.

My beloved goddess, I wish to roam around your lush forests and valleys, and scale the peaks of programming ecstasy with you my most beautiful goddess.

I yearn to plough the depths of your fertility, planting my seeds into your fertile soil, and watch the seedlings sprout and grow into great giant oaks of Mandelbrot complexity and beauty.

I want to bathe in your flowing rivers of ectasy, raise my face to the sky and feel the spray of your golden showers on my face, drink your golden ambrosia and feel the wisdom of your inspiration flow through my veins into my fingers, weaving skeins of golden code that induce envy in the greatest weavers of code.

Oh beloved Goddess Nim, my programming muse.

Bruh!!

.....

I ought to stop here before I cause a global crisis of PEKBACs among diehard Nim programmers.

TBH, I didn't see it at first, but those beautiful mountain peaks and valleys have converted me into a diehard Nim programmer.

PS. Should I post this on the Nim Slacks, Reddits, Matrixes et al?

As other commenters have noted, this is a stretched across the front and back. It makes me think this illusion was not intended and is more an artifact of having a mirrored image so that the back is a reflection of the front. I don't see any issue with the book cover as it appears on the linked Amazon page, for example.

There may be compensating syntactic factors in the large to English word bitwise & boolean operators in the small -- such as being able to skip parentheses in command-style function call syntax and define your own operators (to bring back brevity surgically) that are even implemented as templates or macros. Maybe you can have it all? { famous last words when trade-offs rear their heads :-) }. Personally, whenever I switch from Nim to any other PL (except maybe Unix shell) things always feel much more verbose.

EDIT: For example, say you want Python's Walrus operator. You can just do this (although you can often just use a slightly more verbose parenthesized `let` expression):

    proc `:=`*[T](x: var T, y: T): T = (x = y; x)

or maybe you want `myvar |= flag` like in C/Python. You can also do that:

    proc `|=`*[T, U](a: var T, b: U) = (a = a or b)

But both of those could also be templates or macros that get the whole AST, can pick the AST apart, and emit whatever Nim code you actually want.

In fact, since Nim has nicely nested scopes & hygienic templates, you can define a bunch of operators in a library `template`, called say `unsafePtrArith` for pointer arithmetic, import that and then make them available in a little sub-scope to your code like:

    unsafePtrArith: a += 5

or

    unsafePtrArith:
      b += 4
      c += 3

Can you give examples?

In my experience, Nim macros (but not templates) can succumb to verbosity in their implementations because manipulation of the AST is generally imperative and can become quite involved in the details of syntax nodes.

Other than that, with the expressiveness of type definitions in Nim, my experience has been that routines often end up short and dry. Learning to wield helpers such as {.push.} and {.pop.} can be helpful in that regard, just depends on what you’re doing.

“Nimrod” was, to my knowledge, a biblical reference:

Cush was the father of Nimrod, who became a mighty warrior on the earth. He was a mighty hunter before the Lord; that is why it is said, “Like Nimrod, a mighty hunter before the Lord.” The first centers of his kingdom were Babylon, Uruk, Akkad and Kalneh, in Shinar. From that land he went to Assyria, where he built Nineveh, Rehoboth Ir, Calah and Resen, which is between Nineveh and Calah – which is the great city.

— Genesis 10:8-12

https://forum.nim-lang.org/t/9591#63054

This is probably a better url https://nim-lang.org/features.html

It's a blog post. The homepage (accessible via clicking the logo on the blog page) does include such a paragraph.

I've seen plenty such projects omitting this on their homepage, but it seems odd to expect it of every deeplink.

Considering this is a link to a blog post about a book, you could look at the description of the book?

It's the same reason everything digital and downloadable isn't free: there's a cost to create it and there's a value to it.

For a language developer to charge for a book about that language, I think that's a completely valid way to make some money off of their work.

Even the Rust book, "The Rust Programming Language" is available freely online [0], but also as a print and ebook for sale via NoStarchPress [1].

[0] https://doc.rust-lang.org/book/

[1] https://nostarch.com/rust-programming-language-2nd-edition