I've been away from Nim for about 9 months. Can anyone give me a quick update about what happened in this time to help me get back on track?
A summary of the last things I did and my level of understanding Nim at that time: https://news.ycombinator.com/item?id=13357533
Anything improved, like the better concept system from @zahary? New interesting projects / repositories?
You should be able to look at the release notes from the past releases.
However, the new web site doesn't make that easy to do. The files sit in the web\news directory of the repository, but how you access them from the web site is a mystery to me.
Changelog for 0.17.0 https://nim-lang.org/blog/2017/05/17/version-0170-released.html
In home page of the web, there's section for featured project like Karax (a Single Page Application framework), and zengine (game framework).
However, the new web site doesn't make that easy to do. The files sit in the webnews directory of the repository, but how you access them from the web site is a mystery to me.
You access them from the blog: https://nim-lang.org/blog.html. Why isn't this obvious?
Why isn't this obvious?
Blog didn't register with me as being what I was looking for. :-)
You access them from the blog: https://nim-lang.org/blog.html. Why isn't this obvious?
Because it should be named "news" instead?
I've been away from Nim for about 9 months. Can anyone give me a quick update ...
We keep accelerating toward C, but v1.0 remains elusive... :(
I am not bashing Nim; I am speculating about what (IMHO) it could be doing better. Key word: focus.
This thread is about summing up the last 9 months, and my humble summation is that, as far as I can tell, things haven't moved much. Is Nim marching steadily towards reasonable version 1.0 goals? If so, this isn't very visible to lay observers. Is Nim more popular relative to its competitors compared to 9 months ago - if not, why? It's not because they have more sophisticated mataprogramming, but because they're giving large and specific classes of programmers what they wanted in a new programming language.
It seems that a new programming language that's "a jack of all trades, master of none" is not what a lot of people are actually willing to use. It is better to be a "jack of all trades, master of (at least) one", and that master "killer app" is how you pay the bills while learning more trades.
The first McDonald's only served a handful of choices that most people wanted. One needs to get the business off the ground first, and expand it later as you get enough working capital (compiler code contributors, bug reports, modules, tooling, tutorials, cash donations, corporate sponsorship, etc). And then eventually you can build Xihulou.
Nim has a clear vision -- it's just that I fail to communicate it:
Nim is a simplistic systems programming language with an AST based macro system on top of that.
I'm sorry, I'm not very bright. To me that seems much less clear than the vision of Nim's top competitors (see above). To whom does this vision appeal?
What makes Nim more "simplistic" than "systems programming languages" like D and Rust (and, if using a much looser definition: Go, Swift, Crystal)? And is its AST-based macro system competing with Template Haskell for theoretical papers, or is it a means to an end?
In a Quora answer I summed up what I see as Nim's top strengths: performance to productivity ratio, safety to syntax cleanliness ratio, license simplicity (very important to gaming companies, not just ethics nerds like me), and portability. I think that's already too many.
I don't know if Nim can claim the "performance to productivity ratio" crown in light of the recent takeoff in Crystal's popularity. For people coming from other scripting languages, Crystal-like languages that go out of their way to be as close to JS / PHP / Python as possible (which, as we've previously established, isn't the direction in which you want to take Nim) would probably do very well also.
A lot of people really liked your quote that "Nim is essentially Ada + a GC with a friendlier syntax". I think that would make a great initial focus and selling point for Nim.
Almost all of its features can be found in other languages too.
Some "other languages" have had lots of devs and lots of paid hours (in industry or academia) to polish those features and manage complexity. Successful new grass-roots programming languages tend to start with a particular focus. D started out as a much simpler language, and added features after it mastered the basics. Even Google isn't replacing everything with Go, but keeping it focused mainly in network services. Nim is very ambitious, and that's great, but not when it comes at the expense of the fundamentals.
New features arrive slowly (heck, isn't that what you just complained about?) and more effort is spent on bugfixing and QA than on anything else.
I complained about just the opposite: features over focus. I am encouraging focus on quality, stability, and documentation of Nim's core features; the 20% of the language that gets 80% of use. It's very sad to see Nim not growing in popularity while its more focused and targeted upstart competitors are gaining.
In order to turn it into a fruitful discussion: What feature should we remove from Nim?
There's no reason to remove anything, just say these things are "experimental" and on the back-burner until more crucial goals are met.
I didn't mean that Nim has a "zillion unfocused ideas" (it's not a real number and a general point about business plans), but the top example going through my mind as I wrote that was karax. You can obviously work on whatever you want, and I am very grateful for everything you do, but IMHO that isn't a top focus for getting Nim off the ground. Nim's attempt to compile to both C/C++ and JavaScript, while extremely interesting, is an example of "Chasing Two Rabbits"...
Stability, bugfixes, and documentation are top priority. Maybe focus on one specific flagship developer stack (editor / C compiler / debugger / etc) to provide the perfect developer experience. Anything that a typical Python programmer doesn't understand probably isn't a priority for v1.0.
(IMHO)
Dude, you are over-complicating things! :o
In the last 9 months, what happened?
Well, I got interested in Nim, that happened, and I guess a lot of other people did try Nim out as well, seeing that C and C-like languages (Odin, Jai, .. ) is seeing a revival. Perhaps because of C++ fatigue? Back to basics?
What I dig about Nim is that it isn't a LLVM front-end, but - and that is genius - produces C / C++ / Javascript. And that, finally! I can get to go completely mental with meta/generic programming. That is near impossible to achieve in C++ (without going nuts), and Rust doesn't seem to be any better to be honest..
So, you are bitching about no progress being made in 9 months? What have you contributed? How much progress should there have been? Should a project progress at a constant pace? I don't think so. Too often, especially in the Open Source community, we are all too eager to deem a project dead if there hasn't been any (visible) progress for a month..
[edit] So, I am here because I wanted to go back to the simplicity of C - you can actually know everything there is to know about that language, unlike C++! but at the same time need something with a bit more punch to it. Odin and Jai looks promising, and they led me to choose Nim, because it actually is a well developed language with a community / functioning ecosystem (unlike Odin and Jai).
Sometimes, progress is also what happens in a community, you know.
Finally, I am a C++ programmer turned C, and haven't been into Python much (don't like the huge size of the runtime environment), so I don't know what you're driving at when you mention Python programmers? Do you view Nim primarily as a route from Python to a C-like environment? I personally see Nim as a great way to become more Pythonic in my coding, with a dash of Lispy macros. ;p [/edit]
Oh so it's about Nim v1.0 again. I wanted to release that years ago but the community talked me out of it. Shrug, sometimes the community is just wrong. ;-)
I didn't mean that Nim has a "zillion unfocused ideas" (it's not a real number and a general point about business plans), but the top example going through my mind as I wrote that was karax. You can obviously work on whatever you want, and I am very grateful for everything you do, but IMHO that isn't a top focus for getting Nim off the ground. Nim's attempt to compile to both C/C++ and JavaScript, while extremely interesting, is an example of "Chasing Two Rabbits"...
It's not "extremely interesting" (is that another term for "research toy"?), it's important as the browser is ubiquitous as an application development platform (as bad as that is...) and many other languages do the same already. That's actually just part of the "playing to catch up".
Working on Karax pays my bills ... working on Nim v1 does not. You care about Nim version 1, as do I. The people who pay me have more concrete problems though. Like writing SPAs or having excellent C++ interop to leverage the game engines written in it. Or having stable C++ code generation in order to improve compiletimes to keep it competetive... And here you are telling me how to run a "successful" business.
A lot of people really liked your quote that "Nim is essentially Ada + a GC with a friendlier syntax". I think that would make a great initial focus and selling point for Nim.
Never met anybody who cared about Ada. As a "selling point for Nim" that is a stillbirth, as far as I can tell.
In a Quora answer I summed up what I see as Nim's top strengths: performance to productivity ratio, safety to syntax cleanliness ratio, license simplicity (very important to gaming companies, not just ethics nerds like me), and portability. I think that's already too many.
So ... leave things out in your summary the next time?
I don't know if Nim can claim the "performance to productivity ratio" crown in light of the recent takeoff in Crystal's popularity.
There you go then, don't list that anymore, that title clearly belongs a language that is as obscure as Nim. :-)
I'm sorry, I'm not very bright. To me that seems much less clear than the vision of Nim's top competitors (see above). To whom does this vision appeal?
The benefits of meta programming (and its downsides) have been enumerated, I myself gave plenty of talks about it, I don't know why I need to repeat these here again. It's not that you are "not very bright", you seem to want me to premasticate everything for you so that you can give better answers on Quora and Reddit. And that's ok, so read on.
What makes Nim more "simplistic" than "systems programming languages" like D and Rust (and, if using a much looser definition: Go, Swift, Crystal)? And is its AST-based macro system competing with Template Haskell for theoretical papers, or is it a means to an end?
Compared to Rust/D:
Some "other languages" have had lots of devs and lots of paid hours (in industry or academia) to polish those features and manage complexity.
Yes and Nim has meta programming instead so that you can implement the features yourself and the core language stays lean. That was the plan/"focus" anyway, in practice IMO we need to remove features (but which ones?) to get there.
Successful new grass-roots programming languages tend to start with a particular focus. D started out as a much simpler language, and added features after it mastered the basics. Even Google isn't replacing everything with Go, but keeping it focused mainly in network services. Nim is very ambitious, and that's great, but not when it comes at the expense of the fundamentals.
The truth is that D's development offers a ridiculous amount of similarities with Nim's development. And IMHO "we can do better than C++" is less of a "focus" than "let's have a simple core but metaprogramming". Go's "focus" is more bizarre than that of any other programming language ever invented. "We are a billion dollar company only hiring the very best developers, but we cannot design a parametrized type system and/or think our developers cannot handle it. Or a sane error handling system. Or a concurrency model that is free of data races and deadlocks. Or a compilation model that does away with extensive runtime reflection."
In order to turn it into a fruitful discussion: What feature should we remove from Nim?
method at least, once vtref and the like have landed.
Nim is a simplistic systems programming language with an AST based macro system on top of that.
Why simplistic? IMO it's fairly rich, but not overly so, like C++.
Anyways, I see Nim as a wide spectrum language, suitable for a large number of tasks, especially ones where achieving "close-to-the-metal" performance is important. That appeals to me.
I'm sad to hear that the JS backend is what's getting money, but I do JS development too so I commiserate, which means I feel miserable about writing JS too.
"let's have a simple core but metaprogramming"
I like that, a lot! :)
I don't care about Ada either ;)
What I would like is a language that is expressive and as simple as possible - I hope that the C / C++ "backend" will stay - and Nim is that, to me.
I don't need any more selling points, to be honest.
What I would like, though, is that "people" would blog about Nim, do videos about it and perhaps even tutorials - I think that's much, much better than claiming to be a better other language.
(( I will blog about Nim, eventually, but right now I am not much of a Nim programmer, to be honest. ))
Developers are not stupid - we know a good thing when we see it.
"let's have a simple core but metaprogramming"
I like that, a lot!
Yeah, I have been programming for about a year, and messed around with a few languages (C# and Python mostly), then fell in love with C due to its simplicity. Unfortunately, that simplicity made some things a pain to do (for me at least). I have no idea how to sell Nim to a broader audience, but I love it because it lets me reason about problems as I would in C, but with tonnes of QoL improvements that make things much more approachable to me, as a hobbyist programmer. Pretty much the opposite of Rust, which seems brilliant in many ways, but made me want to cry every time I tried to do anything remotely complicated with it.
What I would like, though, is that "people" would blog about Nim, do videos about it and perhaps even tutorials - I think that's much, much better than claiming to be a better other language.
It would be nice if there was more material available for learning how to work with Nim. Moreover, I think it is such an ideal first language for people to learn, that it would be fantastic to have resources geared towards teaching programming, using Nim. I would love to be able to contribute something myself, but based on where I am in my own learning, I wouldn't feel confident to do so. Plus I can barely find the time to do the programming I want to do, never mind try to blog about it :(.
Leaving aside the discussion about fav lang,
One of great additions is this PR, Fixed “RFC: improving JavaScript FFI” (#4873)
Not to underestimate other stdlibs, improving JavaScript FFI should yield practical purpose, unrelated to whether people like JavaScript or not. jsffi module is very nice lib :)
There's also bitops module.
Most programming today is incredibly bureaucratic.
Nim makes programming fun again and does away with a lot of the beaurucracy, the way Python and Lua do; But unlike Python, you don't have to give up static typing, fast runtime, ease of distribution. For now, compared to Python, you give up some aspects of the REPL, and the ecosystem (many packages, a lot of documentation) but I think both of these have improved tremendously.