Bananaranha

Leopard and Snow Leopard brought a lot of enhancements, new features and under the hood goodies for Cocoa development. From garbage collected Objective-C 2.0 to Grand Central Dispatch and blocks, programmers sure got a lot of shiny new toys to play with. We also know since WWDC that they are working on a revamped version of the XCode IDE, probably scheduled for release along with OS X 10.7, Lion.

Well, according to well informed sources inside 1 infinite loop, that might not be all. Apple has been secretly (duh!) working on a next generation computer language, code-named “Chocolate”, with the intension to bring OS X development well into the 21st Century.

Mac pundits have been asking for just such a thing for years ― and Jesper nearly spilled the beans. After all, powerful as Objective-C is, it is still essentially a 30 year old technology from the glory days of NeXT. Even though it holds up wonderfully, the C heritage constraints it a great deal, not so much in power (C can do anything) but in convenience, expressiveness and safety. Now that the kids are used to all the fancy stuff that languages like C#, Ruby, Scala, et al provide, Objective-C seems a little stale. Not the best foundation for the next 25 years of OS X coding.

Enter Chocolate.

(Chocolate, btw, is the internal codename of the project, obviously a pun on “Cocoa”. My sources don’t know whether Apple plans to keep it for the public launch of the language, but it sure sounds nice and friendly).

Chocolate is a modern, high performance, object oriented language primarily targeting OS X. The aim of the Chocolate project was to rethink Objective-C in terms of contemporary programming languages and idioms.

The main goals of the project are:

- Chocolate should be compatible with Objective-C frameworks (such as Cocoa). This includes calling and subclassing Objective-C code.
― Chocolate utilizes the Objective-C 2.0 runtime for messaging, garbage collection, etc.
- Chocolate should provide automatic memory management.
- Chocolate should support major Objective-C features such as Messaging, Protocols, Categories.
- Chocolate should streamline Objective-C’s syntax dropping the C compatibility requirement.
- Chocolate should support reflective and dynamic programming and provide modern language facilities.
- Chocolate is designed to be compiled into native code but can also run in a VM with JIT compilation (though no such VM currently exists).

So it’s not an evolutionary step to the unknown, but mainly a pragmatic building upon the strengths of the existing infrastructure. I’m told that Chocolate leverages LLVM heavily.

Among the exciting new features is first class support for namespaces (finally!), annotations, blocks, generators, out parameters, and a whole lot more. In Chocolate, everything is a pointer ―and garbage collected. (There are provisions, though, for writing “unsafe” code, either by dropping to Objective-C/C or by marking a specific code segment, a la C#. The new language keeps the familiar selector naming scheme and data types such as String are compatible and interoperable with their NS counterparts. Chocolate, btw, also does away with header files.

Apple does not seem to want to deprecate Objective-C (at least not for a couple of years), so the lineup of languages for OS X development should probably read like this:

ObjectiveC (generic programming, legacy codebases)
Chocolate (generic programming, new codebases)
C (systems programming, base frameworks)
C++ (systems programming, base frameworks)
MacRuby (scripting)

As of yet, there is no information about whether Chocolate will run on the iOS, but I think it’s a no-brainer that it will.

For a small taste of the language’s syntax, consider the following snippet:

import Foundation;
import NSDate;

public class CustomObject extends MyCompany.Writable {

    public CustomObject(){
    }

    public static hello(){
        NSLog(@"Hello World. The date is {0}", NSDate.date());
    }

    public writeMessage(string msg, times:int times){
        times.repeat{
            NSLog(@"{1}", msg);
        };
    }
}

CustomObject o = new CustomObject();
CustomObject.hello();
o.writeMessage("This text will be repeated", times: 3);

Other stuff or interest is the inclusion of the elvis operator (a curiosity adopted from Groovy), and a LINQ like language that can be used to work with Core Data or any Chocolate collection. There’s also first class support for debugging statements (no need to use preprocessing commands to turn them on or off), assignments that not yield boolean results, the “and”, “or” and “unless” operators (!) and indexed properties (classes that work like an array).

For another basic insight into the language, take a look at the category this post is assigned to.