Rust has a richer set of safe memory management primitives than Nimrod does (Nimrod is reliant on non-thread-safe deferred reference counting with stack scans, while Rust has thread-safe unique ownership and thread-safe RC as an option), so I'm not sure I agree that Nimrod is the only language that can do soft real time. It's definitely a neat language though.
The dot-syntax for accessing object properties is much more recent though (2009?).
Declare a plain getter method:
-(id)foo;
Call it with dot syntax: id foo = obj.foo;
Works fine. Now declare it as a property: @property id foo;
Call it without dot syntax: id foo = [obj foo];
Works fine. They are completely unrelated and just introduced at the same time. You could take dot syntax out of the language without affecting properties in the least. You could take properties out of the language without affecting dot syntax in the least.(There is one exception to this, and that is the part where dot syntax understands and calls custom getter/setter names for properties. But that is the only place where they even touch, and it certainly doesn't mean they're somehow integrated.)
However that's a pretty arbitrary definition, since properties pre-date the introduction of that directive.
Using the wishy-washy definition doesn't help, in any case. Nobody would say that e.g. autorelease is a "property", but you can still call it with dot syntax.
You know that the dot syntax is a mechanism that matches with the conventions for property access, and no other access pattern.
You also know that its possible to call zero argument methods that aren't accessors using the dot syntax.
I don't believe that you think that this is the purpose for which the dot syntax was designed, and yet you bring up 'autorelease' to support your position.
As I said, based on your specific definition, you are correct, but using denigration, a false straw-man 'quotation', and dishonest examples doesn't make your definition fit the evidence.
As I said, and you sidestepped, properties pre-date the directive, therefore the directive cannot be the sole definition of what properties are.
Well, how the fuck can I argue against that? Sure, you must be right. Clearly I could not possibly disagree with you for any other reason.
Seriously, fuck off.
You then went on to argue that your point of view was the only reasonable one.
If you addressed the actual question instead of being aggressive and insulting, we might have had an interesting technical discussion.
This catches me. Especially for soft-realtime stuff. Because I am looking for strongly, explicitly typed in-game logic language - which needs deterministic and symmetric coroutine.
I have to check it out.
Graphics part is already mostly written in C/C++. I won't use immature languages for low-level system due to library support and debugging ability
I am still reading the manual, but Nimrod doesn't seem to have coroutine support. Do you have any idea?
Ask the guys and gals in #Nimrod on freenode, they're super Super helpful -- I'm not well versed enough in parallelism and concurrency to answer your question, but they are!
It makes for easier reading of the codegen (reading C source is easier than reading machine code, even if it's generated C source) and before LLVM made it much easier to leverage C compiler optimizations & multiplatform support.
* Objective-C is from 1983, do you? It's not exactly new. ;)
* Nimrod is pretty fast and as the only language even supports soft-realtime applications out of the box. Besides that it feels the nicest to use and has a fat standard library with stuff like Redis. Sorry, I only played with that language, but already feel like a fanboy
* About GC. Yes, that's a problem of all newer languages, but whatever implementation you choose there are advantages and disadvantages and which one is the right one also depends a lot on the language itself. Sometimes you are better off with your big fancy algorithm and sometimes you really just want good old reference counting. But yeah, GC is the big great topic and I am sure it will be for the next few decades.