Hacker News Reader

Comment by tete | Hacker News Reader

A few small addendum:

* 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.

View on HN

> Nimrod is pretty fast and as the only language even supports soft-realtime applications out of the box.

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.

> Objective-C is from 1983, do you? It's not exactly new

The dot-syntax for accessing object properties is much more recent though (2009?).

Announced in 2006, released in 2007 with Mac OS X 10.5.

It's a pretty unimportant feature though. It's just some very minor syntactic sugar for a regular message send. All uses of obj.property can be replaced with either [obj property] or [obj setProperty:...] depending on whether it's being written or read. It's about as significant as when C added the ability to declare variables in the middle of a block or support for // style comments i.e. not at all.

For now perhaps, but it does seem as though properties are gradually being lifted into a first class language feature rather than a set of conventions.

Properties are, but dot syntax is almost entirely not about properties.

I'm not sure I understand what you mean by that. Dot syntax is a way to refer to properties independent of the usual message sending syntax. How can it not be about properties?

Because... it's not?

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.)

If you define 'properties' as only use of the @property directive, then what you say follows.

However that's a pretty arbitrary definition, since properties pre-date the introduction of that directive.

Well no, the wishy-washy "properties are certain kinds of methods that we can't really define in a particularly concrete manner" definition of properties is the arbitrary one. Saying that properties are those things which are declared with @property is pretty non-arbitrary. That's the definition the compiler users, that's the definition the runtime uses, and that's the definition I use.

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.

I seriously doubt your intellectual integrity here.

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.

You've decided that I must agree with you, and the only reason I could possibly disagree is that I have no intellectual integrity.

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 aren't reading what I wrote. I didn't decide you must agree with me. I accepted your point of view and told you why mine differs.

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.

Yes but that's pcwalton's point. The OP complained that Rust is slow, in part, because of that feature and pcwalton pointed out that A. most languages do it now and B. that it has no runtime cost because it's just sugar syntax.

Sure. And I'm just saying that it doesn't really matter what year ObjC got them because they're not a big deal anyway.

> Nimrod is pretty fast and as the only language even supports soft-realtime applications out of the box.

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.

2D or 3D, out of curiosity? I'm just getting my feet wet playing with game programming (a 2D engine, and likely using Nimrod itself for the game logic as well as engine) in nimrod, and am going to be blogging about it.

3D. I don't think there's really a a lot of difference… Anyway it's just a small project, not a block-buster.

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?

No coroutines per se, but it does have really nice native threading support, and I'm nearly certain that coroutines could be easily put in userspace. It's a powerful language in that regard.

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!

Glad I wasn't the only insta-convert to Nimrod! Such a neat language!

It does look very interesting. I was surprised to learn that it cross-compiles to C before being compiled. I'd be even more interested if there was an IntelliJ plugin for Nimrod.

Why? That's a fairly common strategy, GHC worked the same way until a few years ago (and IIRC you can still ask for compilation to go through C).

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.

Reply on news.ycombinator.com