Swift impressions

ARC may be less likely to get memory paused on release, but ARC doesn't compact free memory, and therefore fragmentation can cause object allocations (malloc) to become more expensive, possibly leading to pauses.

If you use non-copying GC that doesn't compact (ARC doesn't compact), then there are low pause GC algorithms out there that give pretty good bounds (e.g. 5ms pause).

I'd like to see actual benchmarks of both ARC and say, mark-and-sweep on a mobile device rather than speculation and opinion, and both benchmarks must get the same static compilation treatment. That is, if escape analysis tells you that the lifetime of the object is bounded by the current stack frame, then allocate it on the stack, and don't penalize the non-reference-counted GC by allocating 100% of everything on the heap.

interface Foo { void foo(); }

class A implements Foo { ... } class B extends A { ... }

If someone renames Foo then A and B fails to compile. If you don't want to use an interface, you do it like this:

class A { abstract void foo(); }

class B { void foo() { ... } }

Yes, it's not exactly equivalent but, this is a rather contrived case that never happens in Java because

a) almost everyone uses @Override because IDEs add it automatically b) Java programmers don't refactor by using VI and editing a base class's method names. An IDE like IntelliJ IDE does all the work automatically. c) if you really want to ensure that a class implements a certain interface, you use a Java interface to enforce it.

This swift feature is interesting, but it's not really anything to sell the language.

Your bit about compile-time code analysis to automatically insert the cleanup code when data is no longer reachable is actually pretty similar to what Rust does today with owned pointers. The downside is that this doesn't work with "normal" code -- you need certain annotations for the compiler to be able to perform this task correctly. In Rust this is done via region pointers (lifetime parameters) and borrow checking.

[1] D. F. Bacon, P. Cheng, and V. T. Rajan, “A Unified Theory of Garbage Collection,” presented at the Proceedings of the 19th Conference on Object-Oriented Programming, Systems, Languages & Applications (OOPSLA), 2004.

What the automatic part of ARC does is, at compile time, analyse the code and automatically add the retain and release messages. If it determines the reference will outlive the stack frame, it adds a retain message. if it determines the reference can no longer be dereferenced (maybe because another object reference is assigned to that variable) it adds a release message.

The runtime characteristics are the same as ARC, it just means the programmer no longer needs to work out where to add the retain and release messages (though they still need to think about reference cycles).

The proper distinction would be between local reference counting and GC at the time of release, and global heap traversal from roots.

[1] http://fitacular.com/blog/swift/2014/06/08/apple-ios-tutoria...

Swift also doesn't perform type erasure. You can do something like the following, as I believe is possible in C#:

  struct SquareMatrix<T> {
    let dimension: Int
    var backingArray: Array<T>

    init(dimension d: Int, initialValue: T) {
      dimension = d
      backingArray = T[](count:d*d, repeatedValue:initialValue)
    }

    subscript(row: Int, col: Int) -> T {
      get {
        return backingArray[row*dimension + col]
      }
      set {
        backingArray[row*dimension + col] = newValue
      }
    }
  }

It is composed by Mesa, Cedar, Modula-2, Modula-2+, Modula-3, Oberon, Oberon-2, Active Oberon, Oberon-07, Ada, Spark, ParaSail, ...

There are quite a few distinctly other languages, though. To name a few: APL, COBOL, Forth, sed, Snobol.

If you want the equivalent of !@Override, a) you can do it with Java8 annotation types and a checker or b) you can just declare the method private.

I'm sure Swift's version also fails to address all of the edge cases people might want to catch. No type system can be complete and catch every use case.