πŸ”₯ Poll: Which features of Swift stand out most to you?

After a year translating C++ code, I've a long list of beloved features: the lack of header files, named parameters, ARC, efficient value-semantic collections, Unicode String, optionals, closures, enumerations with associated values, Swift Concurrency, and all the sugar that enables concise yet clear code, which let me rewrite 152,000 lines of C++ into 29,000 lines of Swift.

But the one thing I'm far too enamored of is functional programming using one-line single-expression read-only computed properties.

16 Likes

Value semantics, type inference, Optional, library-defined fundamental types, argument labels, generics model (including protocol + extension), enum, real Unicode String

Most promising new feature: Swift Concurrency (which is still too young and pretty rough around the edges to make it to the main list)

4 Likes

swift projects are remarkably self-documenting if written properly. i’m always pleasantly surprised how easy it is to pick up uncommented code i wrote months or even years ago.

4 Likes

I love the names of things!

Function arguments having visible outside names is great, and the fact that they read almost like English sentences, for example type(of: 123) :heart_eyes:

Also the fact that Swift uses full words that have meaning, instead of weird abbreviations like other languages! FLT_MIN in C is confusing. You can guess that it's the minimum value of float, but you would be wrong.

the distinction between sort and sorted methods

no weird distinction where some of the types are written fully lowercase, and some are CamelCase


It's not anything complicated, you don't need any compiler features to write good names, but for some reason a lot of languages don't do that.

10 Likes

I think the fact that Apple’s technical writing staff was involved at an early stage must have made a big difference. Most languages are designed in programmer/implementer echo chambers, with perhaps Smalltalk as a notable counter-example.

7 Likes

I like a lot about Swift, really a lot, but probably my top 2 are:

  • progressive disclosure, more of a philosophy than a feature, but a philosophy behind many Swift features, allows to start simple and gradually include more complex mechanics in your code, and makes learning and teaching Swift a breeze;

  • easy-to-use, ergonomic value types, and the focus on value semantics are, to me, the most important Swift features by far, they completely changed the way I think about software engineering in general, and they make Swift stand out among languages that seem superficially similar but are in fact profoundly different, like for example Kotlin.

9 Likes
  1. Protocol conformance via extensions for existing types.

  2. Result builders.

3 Likes

The fact that it runs everywhere , is compiled, and is a cleaner language than either Rust or C++. For high productivity and manageability at scale, it competes with Java while being easier to deploy.

Love the new concurrency and actor stuff!

3 Likes

Upon true reflection on the question, the real star feature of Swift is, unequivocally, this community. Our collective care for the language, help for each other, and stewardship for its future makes us absolutely the best thing about Swift.

11 Likes

So absolutely true. I have not seen this level of expert, authoritative, polite, fast support anywhere else.

(I wish there were some way to take whatever makes Swift Forums so effective and do the same elsewhere.)

4 Likes

Yeah, the signal/noise ratio reminds me of the earlier days of usenet news (comp.sys.next.programmer and related feeds specifically). The active participation of the language core team and other experienced users from both Apple and others (ranging from Indies, academia all the way to other industry players) is a key asset without a doubt. It's definitely one important factor for us.

5 Likes

First class support for optionals and error handling are the two things that stand out the most for me. Especially the latter makes you think β€œthis is so obvious, how come no other language came up with this syntax before Swift?”. The fact that at the same time it managed to bridge legacy (i.e. Obj-C error handling) as well in such an elegant way still amazes me to this day.

5 Likes

Value semantics, specifically the fact that the mutability of an instance of a struct depends only on the variable it's assigned to (whether it's let or var).
This is what enables all swift data structures to avoid having to offer a mutable and a non mutable variant, which is amazing, and something unique to Swift among the mainstream languages if I'm not wrong.

1 Like

Only if we aren't counting C++ as mainstream. Although Swift still does it better. :P

2 Likes

Indeed, looks ok in C++:

struct Foo {
    const int x = 0;
    int y = 0;
};

struct Bar {
    const int x = 0;
    int y = 0;
    const Foo foo1 = Foo();
    Foo foo2 = Foo();
};

void test() {
    const Foo foo1 = Foo();
    Foo foo2 = Foo();
    const Bar bar1 = Bar();
    Bar bar2 = Bar();
    
    foo1.x = 1; // ❌ Cannot assign to non-static data member 'x' with const-qualified type 'const int'
    foo1.y = 1; // ❌ Cannot assign to variable 'foo1' with const-qualified type 'const Foo'
    foo2.x = 1; // ❌ Cannot assign to non-static data member 'x' with const-qualified type 'const int'
    foo2.y = 1;
    bar1.x = 1; // ❌ Cannot assign to non-static data member 'x' with const-qualified type 'const int'
    bar1.y = 1; // ❌ Cannot assign to variable 'bar1' with const-qualified type 'const Bar'
    bar1.foo1.x = 1; // ❌ Cannot assign to non-static data member 'x' with const-qualified type 'const int'
    bar1.foo1.y = 1; // ❌ Cannot assign to non-static data member 'foo1' with const-qualified type 'const Foo'
    bar1.foo2.x = 1; // ❌ Cannot assign to non-static data member 'x' with const-qualified type 'const int'
    bar1.foo2.y = 1; // ❌ Cannot assign to variable 'bar1' with const-qualified type 'const Bar'
    bar2.x = 1; // ❌ Cannot assign to non-static data member 'x' with const-qualified type 'const int'
    bar2.y = 1;
    bar2.foo1.x = 1; // ❌ Cannot assign to non-static data member 'x' with const-qualified type 'const int'
    bar2.foo1.y = 1; // ❌ Cannot assign to non-static data member 'foo1' with const-qualified type 'const Foo'
    bar2.foo2.x = 1; // ❌ Cannot assign to non-static data member 'x' with const-qualified type 'const int'
    bar2.foo2.y = 1;
}

We can still love it even if it's not unique!

2 Likes

Absolutely enums. They've massively changed how I build a lot of code and there's almost nothing bad about them.

Flipping things slightly, I could say that protocols also stand out a huge amount, but mostly because they form the bulk of the "hate" part of my love-hate relationship with Swift :stuck_out_tongue:

3 Likes

Obviously Codable. It has helped me a lot when I wanted to save the user's data inside a struct that conformed to Codable to decode and encode it as a JSON.

1 Like

enuuum.

enum is enum, even if its rawValue is Int. Or if it's not RawRepresentable it's only enum. I missed this very much when I'm in the other languages.
More specifically its strictness and safeness.

2 Likes

I'd say enums, but IMHO they should be more ergonomic, e.g.:

enum E {
    ...
	case a(x: Int, Int)
}

var e = E.a(x: 1, 2)
let v = e.a // this is of type `(x: Int, Int)!`
e.a.x = 100 // change associated value field by name
e.a.1 = 200 // change associated value field by index
if let v = e.a { // optional binding
	v.0 ...
	v.y ...
}
let isA = e.a != nil
2 Likes

Just want to give a big thank you to everyone for the interesting responses so far. There’s no time limit here, so feel free to share if you haven’t already!

6 Likes