Nim Blog

I don't know what @winding means, exactly, but at best this seems highly misleading. Nim had babel packages by around 2010 (when it was called Nimrod and there was a Tower of Babel name scheme) and then nimble packages since 2014 or so. Also, literally 30 seconds on https://nim-lang.org (click on Documentation) and you get to https://nimble.directory/ , search for index and get to adix which has all sorts of efficient Table variants. There has never been much prog.lang. benefit from being "in the stdlib/core" in Nim (unlike Python or Go, say). The benefit is more "software distribution" for the dependency allergic, but the Nim culture is much less micro-deps than seems in vogue lately. All that said, I think having a more batteries core distribution is valuable - just less than you might guess - and practically that needs delegation.

That's actually a great argument for Nim[0]. Easy interop with C, native-speed performance, and a syntax very close to Python in both readability and how quickly you can get something working. Batteries included, automatic memory management without a conventional GC and metaprogramming - is a really cool combination. [0] - https://nim-lang.org/

Came here for the Uniform function call syntax link. This is one of the little choices that has a big impact on a language! I love it! I wrote a little pipeline macro in https://nim-lang.org/ for Advent of Code years ago and as far as I know it worked okay. ``` import macros macro `|>`\* (left, right : expr): expr = result = newNimNode(nnkCall) case right.kind of nnkCall: result.add(right[0]) result.add(left) for i in 1..<right.len: result.add(right[i]) else: error("Unsupported node type") ``` Makes me want to go write more nim.

Impressive! I would love to learn howto implement that in Julia. Could you help me understand how you did that? I'd love to see, if it's possible to create a libc-free, dependency-free executable without Nim (https://nim-lang.org/).

Personally, I switched to Go and soon after to Nim. https://nim-lang.org/ It's great!

A possible alternative to MicroPython is Nim - it's a strongly typed language with Python-like syntax that compiles down to C. Since it compiles to C, it can use existing C libraries without much fuss (just wrap signatures as needed), plus there's no need for a "micro" version of the language. Several members of the community have been working on improving the embedded ecosystem: although I haven't played around with either yet, the nesper library (for the ESP32) and ratel (generic framework: tested for the Arduino/AVR) have been recommended. https://nim-lang.org/ https://github.com/elcritch/nesper/ https://github.com/PMunch/ratel

https://nim-lang.org/ The C++ language designers have made a terrific language with the ergonomics of a four-fingered glove. Nim fits your criteria but doesn’t have the popularity of C++.

Nim - https://nim-lang.org/ Lets you mix and match other libraries with their native ABI as it compiles to C, C++, ObjC and JS + has excellent FFI.

I'd really rather recommend Nim [1] for performance-intensive apps. Its syntax resembles Python, it is far and away safer, but it complies (via generating C) to a full binary, and the resulting binary is very fast. Don't let the fact that it has a garbage collector scare you -- you can turn it off if you don't like it. 1: https://nim-lang.org/

If anybody is looking for an alternative to Python that is also a great 0->1 language but doesn't have the same wall as Python described here, check out Nim[1]. 1 - https://nim-lang.org

re:"weekly roundup"> F# Is The Best Coding Language Today Have you looked at http://nim-lang.org ?

Without knowing what you're trying, I'm often using nim (https://nim-lang.org/) when I want more complexity than a basic bash script, cross-compiled binaries _and_ way smaller binaries than go. It's much like python, easy to pick up, and promising. But not as mature as python, obviously. Go is great, but the binaries are big... not a problem if you've got great bandwidth...

> If your team really knows what they're doing and can take advantage of the flexibility without creating a mess, they can let you move really fast and make elegant DSLs and so on. [..snip..] I never thought I'd say this before, but I would have been happier stepping into C++. Actually, I find Nim language [1] to be a great alternative to C++ as far as compiled, statically typed, high performance modern languages are concerned. Moreover, Nim's meta-programming capabilities (generics, templates, macros) are second to none for creating elegant DSLs. And its syntax makes Python developers feel at home. Preempting questions about garbage collection -- Nim allows to switch off GC and manually manage memory if a programmer so desires. Or you can manually manage memory in some critical parts of your program while letting the rest be garbage collected. [1] https://nim-lang.org/

Gleam[1] is a typed language on the BEAM. It's still in its early days, more so than Rust. May still be worth keeping an eye on. Nim[2] and Crystal[3] also exist. No idea what their web situation is like, but Nim has a JS compile target, that might be interesting. [1] https://github.com/gleam-lang/gleam [2] https://nim-lang.org/ [3] https://crystal-lang.org/

A great choice of companion language to your Python stack would be Nim: https://nim-lang.org/ (not necessarily ML-inspired) but extremely productive and extremely fast. Bonus, v1.0 is right around the corner for Nim. If you're willing to venture out to a place with an evolving scientific ecosystem, Nim is a great choice to do scientific computing as part of a CPython stack (easy integration both ways since Nim compiles to both C/C++).

It seems like all modern languages try to capture their goals in a tagline. The following sites all have similar brands: https://golang.org/ https://nim-lang.org/ https://www.rust-lang.org/ https://ziglang.org/

golangs multiple options (via dropdown) always seemed the best to me https://golang.org/ Nim's line length one is okay https://nim-lang.org/ Although I'm sure you guys debated it to death already I still find it unusual to not be able to find a any example of actual within a few clicks. Committee-driven design is always difficult.

Nim: https://nim-lang.org/ (as a die hard Nim aficionado I absolutely love Nim)

Nim is a language that mimicks python syntax but compiles down to c. Really cool and easily gives you 'fast code'. If you are into this kind of stuff I would recommend you take a look. https://nim-lang.org/

I still find Rust's syntax relatively nice and love Python. A "system" language with similar to Python's syntax is https://nim-lang.org/

Have a look at Nim(https://nim-lang.org/ ). It doesn't have great IDE support, but VSCode plugin works well enough and the language has a lot going for it. Edit: posting this because I'm in the same situation. I like Rust/Nim/Elixir but Go has a great productive ecosystem even though the language is quite "barebones".

The Nim language [0] feels very inspired by Pascal while looking like Python. If you're interested in fast, compiled & typed languages, I suggest you also take a look at it. I personally love its readability. [0]: https://nim-lang.org/

Check out Nim, it's got python style syntax, but it's statically typed and compiles down into performant C and then into a binary. I've been converting a lambda function used at work from Python into Nim[0]: I've had very few issues so far and the performance gains are fantastic (Admittedly my lambda function is pretty straightforward, but still). It's also got support for functional programming styles, with a function composition operator/first class functions etc[1] and a pragma to tell the compiler that a function has no side effects[2]. [0] https://nim-lang.org/ [1] https://nim-by-example.github.io/procvars/ [2] https://nim-by-example.github.io/procs/

I can think of a couple. Write a small toy document database with an integrated ORM. Tables/documents can be modeled as objects and the query API can be built using a functional paradigm. Doesn't need to be fancy. Could be a simple key/value store really. Or how about an HTML generation library? Or how about a toy web server? How about a command line argument parser for your favorite language? How about a small library for geometric calculations? There are many languages that have multi-paradigm support. One of my favorite multi-paradigm languages in still in it's growing phase, but it's fun to learn: https://nim-lang.org/

The language does make a strong case for "code is read more than it is written", so it does make it easier/cleaner to quickly see the keywords, etc. However, 2 improvements that could be made are: 1) being able to write the code as normal (if instead of IF, else instead of ELSE) and then using something like: zu.fmt To format the code (best of both worlds?) 2) Dropping the ending-brace. It will just lead to many errors that could otherwise be avoided --- Also, if you are interested in a similar language, maybe Nim might be worth a look: http://nim-lang.org/

I am a Node.js developer and practically speaking you should probably learn that. But so far I haven't heard anyone mention the Nim programming language which can compile to JavaScript or C and has what I consider to be superior syntax and excellent performance as well as great metaprogramming capabilities. See http://nim-lang.org

Interesting language. Somewhat reminds of me "ooc"[0], though I believe ooc is ref-counted/garbage-collected (? I think. I can't remember, been a while since I've touched it); but being able to easy use C libraries from a relatively low-level language that has nicer high-level constructs is still a beautiful idea, in my opinion. The language I'm using these days for that exact feature set though is Nim[1] -- being able to use {.compile.} pragmas and bring in header/source files, along with the great C type support is wonderful; but again, garbage collector (albeit one that can be tuned and/or turned off). Zig seems to be targeting the "true C replacement" niche, which I'm going to have to keep an eye on! [0] http://ooc-lang.org/ [1] http://nim-lang.org/

Sounds like http://nim-lang.org/ . Just simplifying syntax is not a great idea for a system programming language though.

It is indeed an interesting idea. However, it is hardly the first to do this. The first C++ compiler (cfront) did so [1], and there are other languages that follow this idea still today [2][3]. [1] https://en.wikipedia.org/wiki/Cfront [2] http://chapel.cray.com/ [3] http://nim-lang.org/

Nim targets compilation to C and (I presume C-flavored) C++: http://nim-lang.org/ In terms of playing nice Rust is doing great (no GC, and can create static libraries linkable by C/C++ compilers), but unfortunately requires going through plain C interface.