On the Swift Language
Today, Apple announced a new programming language, Swift.
In good tradition with Apple (and NeXT), the language is extremely pragmatic and focusing on seamless integration with the existing platform. So it should be possible to mix Objective-C and Swift in the same application. This could turn out to be a major win for the language, just like Objective-C was great in that it let you mix Objective-C (the new language) with C (which had all the libraries).
It's ARC (Automatic Reference Counting) again. Granted, ARC is much nicer than the old new/free regime of Objective-C, but so far from what we're used to expect in a modern language.
Especially with complex structures that easily come from some GUI elements referring to model objects, which can easily lead to cycles in the object graph.
Swift has value types of sorts. Whenever you assign a reference to an immutable variable using
let x = <expr> as opposed to
var x = <expr>, swift makes a semantic copy of the value being assigned, making the value immutable in the process. This copying recurses until the types (of generics and/or members) are of reference (a.k.a. mutable) type.
This provides a relatively smooth path to introduce more immutability in a codebase; because mutable and immutable things of the same type can coexist. What is yet to be proven is how this translates into reality ... perhaps someone from the OCaml world (which also has a mix of mutable and immutable) can shed light on that.
Surprisingly, the reference manual mentions nothing about threads or processes or the like. So from the outset there's not concurrency story.
IMHO, one of the hardest parts of writing apps is the concurrency which has many sources, but most notably concurrent GUI updates and network activity.
So initially, this looks a bit dissapointing, but maybe there is a way out. Swift's value types and pattern matching might be a good combo to provide passing things from one thread to another. But as long as there is a strong undercurrent to provide backwards compatability and integration with Objective-C as it is, this will be very hard to accomplish as far as I can see.
There is only one way to do concurrency right: isolation. Just like Rust or Erlang has it, each process needs a separate memory space, and shared data needs to be 100% controlled by the system. It's the only thing that I have seen which works.