
About Nimrod's features - dom96
http://picheta.me/articles/2013/10/about-nimrods-features.html
======
girvo
I love Nimrod. Go hang out in the #nimrod channel on Freenet sometime, the
people there are friendly, awesome, and helpful.

I just wish I had a proper use for it so far! It's such a nice language to
play with, but as my day-job stuff is mostly web-based I haven't had a chance
to use it in production yet (that said, the Nimrod forum is coded in Nimrod
itself, which is pretty cool!)

I highly suggest giving it a try.

------
scrrr
For evangelists of Nimrod: Take some time and write a page about it on
Wikipedia. There doesn't seem to be one yet. [1]

[1]
[http://en.wikipedia.org/wiki/List_of_concurrent_and_parallel...](http://en.wikipedia.org/wiki/List_of_concurrent_and_parallel_programming_languages#Unsorted)

~~~
dom96
I wrote one. It's in my sandbox [1]. The original article got deleted despite
my attempts to keep it alive due to lack of notability [2].

[1]
[https://en.wikipedia.org/wiki/User:Dom96/sandbox](https://en.wikipedia.org/wiki/User:Dom96/sandbox)

[2]
[http://en.wikipedia.org/wiki/Nimrod_%28programming_language%...](http://en.wikipedia.org/wiki/Nimrod_%28programming_language%29)

~~~
rurban
I dared to recreate it. May those uninformed deletionists come again.

So far the new/old page got one positive review.

~~~
ErrantX
I've removed it again, sorry; this is not the way to fix the problem. Mostly
all you're going to do is stir up bad feeling (especially with that attitude)
and end up getting the article title protected from recreation.

Unpleasant.

The Wikipedia community has agreed a set of rules for creating articles. In
this case the community review noted that no independent sourcing covered this
language. If a deleted article is recreated substantially the same, it is
removed.

So, there are _correct_ options... (I appreciate from outside the community it
is not always clear what they are - so a list!)

* Find those sorts of sources

* Ask for a review of the deletion [https://en.wikipedia.org/wiki/Wikipedia:DRV](https://en.wikipedia.org/wiki/Wikipedia:DRV)

* Work to clarify Wikipedia's specific notability rules for Software (here's a good place to start: [https://en.wikipedia.org/wiki/Wikipedia:SOFTWARE](https://en.wikipedia.org/wiki/Wikipedia:SOFTWARE))

* Fork Wikipedia and write about programming languages (I'm a big proponent of this, but no one seems willing to make the effort).

I see no reason in time, and there is plenty of time, that Nimrod won't obtain
the sort of coverage that merits coverage in a general encyclopaedia.

~~~
jimktrains2
>I've removed it again, sorry; this is not the way to fix the problem. Mostly
all you're going to do is stir up bad feeling (especially with that attitude)
and end up getting the article title protected from recreation.

> Unpleasant

That's right, deleting it again is unpleasant and no way to fix the problem
and is a good way to stir up bad feelings and screwing over the topic from
ever having a decent page.

> The Wikipedia community has agreed a set of rules for creating articles. In
> this case the community review noted that no independent sourcing covered
> this language. If a deleted article is recreated substantially the same, it
> is removed.

Independent sources do, the Deletionists, like yourself, just don't like them.

> I see no reason in time, and there is plenty of time, that Nimrod won't
> obtain the sort of coverage that merits coverage in a general encyclopaedia.

What type of coverage is that? What type of coverage could a programming
language get that would allow it to be part of Wikipedia? Even Go only has a
single newsworthy citation, the rest of blogs and its own site.

> * Fork Wikipedia and write about programming languages (I'm a big proponent
> of this, but no one seems willing to make the effort).

Because it's a stupid idea not to have at least basic information on wikipedia
about these language. There are projects that aim to do that, e.g.
[http://rosettacode.org/wiki/Rosetta_Code](http://rosettacode.org/wiki/Rosetta_Code)
so perhaps you should get off your high horse.

~~~
ErrantX
> Because it's a stupid idea not to have at least basic information on
> wikipedia about these language.

Why? Why is it stupid? Why does Wikipedia _have_ to cover it?

This argument could be extended to everything. My company, that I work for,
why couldn't I cover that using the couple of blogs about it and our own site?

Once you make this argument the scope of Wikipedia expands dramatically
(remember, it is a founding principle that Wikipedia is _curated_ not an
indiscriminate collection).

If you're arguing that the notability rules are problematic for programming
languages and need to be revised, then I agree.

Simply recreating articles is not going to affect that, leading to
inconsistent results and well meaning efforts to clean up content causing this
sort of confrontation.

Don't just drop content over and over in the hope that it will stay, that's
not a workable approach. And, yes, it is rude. Throwing out ad hominems
because you didn't get your way is also not very nice. Engage in the
community, bring together some solid guidelines, and _then_ create the content
that meets those guidelines.

I've given you the starting base to bring those changes about - if you want to
take that and go with it then please do make the effort.

If your position is that Wikipedia should cover everything, ever, then you're
at odds with the Wikipedia community and should fork it (but I'd suggest
you'll soon realise why those rules exist!).

------
stewbrew
This is all good and everything but: Who uses Nimrod? Who are the people
behind Nimrod? Will they still be/stand behind Nimrod in 5-10 years from now?

I didn't know Nimrod has a Javascript backend. This makes it even more
interesting. The multitude of backends and the presumably small size of the
core developer group makes me wonder though how well they are tested.

~~~
a8da6b0c91d
The problem with D/Nimrod/Go/Rust is the kind of people who would use them
have already invested heavily in coping with the pain of C++ and have solid
tools. As languages the alternatives are only maybe 2X better than C++, which
is almost entirely countered by the fact that you will hit compiler and
library bugs that you wouldn't when using mature C++ components and tools. As
soon as you waste a day writing your own library wrapper that you would have
taken off the shelf in C++, the relative elegance of Nimrod becomes moot. It
seems like the alternative languages need years more to build steam.

~~~
pcwalton
No tool in existence can make C++ memory-safe. If there were such a tool, then
we wouldn't have had any reason to create Rust. But C++ is so fundamentally
unsafe that making it safe requires a new language, as far as anyone can tell.

You do give up maturity and the ecosystem when using an alternative language,
but there are some features that are critical for certain application domains
that C++ can never have without massive incompatible changes.

~~~
angersock
but but but boost c++11 lambdas c++14

do you even program in cpp

------
thinkpad20
Very cool stuff. I'm personally more interested in functional languages these
days, but there's still a lot that imperative languages have to offer (duh).

As a huge fan of C, I nonetheless am not a huge fan of its syntax, outside of
C itself. I'm glad that there are some who have realized that you can do
efficient imperative systems programming in a language without curly braces :)
Not that that alone is a reason to use the language, but all in all it seems
very promising.

Between this, Go, Rust and D, there seems to be an excellent crop of new-breed
imperative languages which are simultaneously emphasizing efficiency, safety,
ease of use and productivity, to varying degrees. It would be great to see
these languages mature into legitimate alternatives to C/C++.

------
codexon
_Nimrod 's GC is perfect for real-time software like games. It uses a deferred
reference counting algorithm which can have pause times as small as 1ms._

How does Nimrod deal with the multi-thread reference counting performance
problem?

Languages like Java don't use ref count and CPython has a global lock because
multiple threads accessing a ref count mutex kills performance.

~~~
rayiner
Deferred reference counting (DRC) doesn't suffer from the multi-thread
reference counting problem. CPython uses immediate reference counting--ref
counts are adjusted live every time a reference is created or deleted.
Deferred reference counting works differently. Generally, it doesn't adjust
reference counts for pointers in the stack/registers at all. Instead, it
pauses all threads and scans the stack/registers with all threads paused to
find references, just like a tracing collector. For references from the heap,
a deferred reference counting algorithm will use a write barrier that queues
the reference count in a local buffer. The locally-buffered
increments/decrements will be resolved during the global pause.

The difference between a DRC algorithm and a tracing algorithm is what needs
to happen during the GC pause. A tracing collector has to trace all live
objects (even a generational collector will trace all live objects
eventually), in order to free any memory. A DRC collector just has to apply
the deferred increments/decrements. Once those increments/decrements are
applied, zero-count objects can be immediately deleted.

------
rufugee
Looks interesting, but I worry when I see that templating support. After years
of doing ruby development, I've come to believe that runtime generation of
code is evil 99% of the time.

~~~
dom96
Nimrod's templates do not work at runtime, they work at compile-time.

~~~
rufugee
Ah, I see. My apologies. Thanks for clearing that up.

------
gpapilion
I'd still say the syntax is C-like, the same was I would argue python has a C
like syntax. Braces, and semicolons are there for the parser not for people.

I'm curious to see how much traction this gets. Its certainly more appealing
to me than rust, or even go. Hopefully usage of C libraries is pretty easy,
since I feel like thats always the missing piece in a new language.

~~~
thinkpad20
I think you mean semantics. Like nearly any imperative language, the code is
structured as blocks of statements which are evaluated sequentially. This is
semantics, and python and C are largely the same in this regard. However,
syntactically, they are not the same.

------
reddit_clone
Threading support? Nativive or green ?

~~~
pcwalton
Native threads.

~~~
reddit_clone
I looked it up. Nimrod has Erlang like actors, message passing and thread
local GC. All with OS threads (not light weight threads like Erlang).

It is an intriguing combination.

