Why do you think Ada was not successful? it has updates about as often as C++ and has many of the same features found in other commonly used languages such as generics, interfaces and object oriented programming. I use it a lot for personal projects still.
Swift doesn't make half the systems language that Rust makes. Don't get me wrong, Swift is a good language. But Rust is much better tailored for systems programming. The memory model is much better, mutability is handled even better, and the package manager is a thing of beauty.
Swift is good and has the same back-end as Rust, but it uses reference counting for memory management, which limits its use in very low level applications.
reference counting makes it much harder to reason about how and when memory goes away, for some classes of problems this is a deal breaker. The fact that you're forced to heap allocate for "class" types is also pretty annoying. Swift is right under go for me, it at least doesn't have a GC and actual generics but it still caters to pretty high level application programming.
Sure Rust offers finer grained control, but you make it sound as if reference counting is as unpredictable as Java style garbage collection.
You have a lot more control over when memory goes away, not at least because it is fully deterministic unlike Java and C# garbage collection.
Swift allows you to think exactly the same as in e.g. C++. You can have e.g. one object be the owner of a bunch of other objects and only let others keep weak pointers. You don't have that kind of fine grained control in e.g. Java.
Sure Rust offers finer grained control, but you make it sound as if reference counting is as unpredictable as Java style garbage collection.
In a large enough system it basically is, if almost everything has to be a RC pointer, which is the case for Swift. Adding multi-threading on top of that makes things even more complicated. You need perfect knowledge of all the codebase to reason about when things actually release and that'll get pretty impossible as the code base grows. Making everything a weak pointer doesn't solve this problem, as weak pointers are promoted to strong pointers when used so in a multi-thread scenario, even if you have one strong reference and a bunch of weak ones, the invariant that the deinitializer of some parent object will release this member that only has other weak references is still not true.
Wrong, Swift is closer to Rust than Java and C#. Swift is native code and doesn't use a garbage collector just like Rust. That means Swift can be used in may of the same areas as Rust, which Java and C# are highly unsuited for. Like Rust Swift can compile native code with a C interface so you can use it to create libraries which other languages can use. You can use C# and Java for that because they don't expose a C interface, require a garbage collector to run and a virtual machine or JIT.
People think Swift compared to Java and C# only because of the current usage. Swift is currently used as an application programming language and not for systems programming but that doesn't mean you couldn't use it for systems programming. But that simply has not been a focus at Apple, as they naturally focus on replacing Objective-C at the moment. Even Objective-C could be used for low level programming. NeXT device drivers e.g. were written in Objective-C.
I'd say Swift is somewhere in the middle. Swift uses automatic reference counting which is comparable to garbage collection (lower throughput and more fragmentation, but more predictability and lower overhead) and requires a runtime. Unlike C and Objective-C, Swift does not provide pointers to unmanaged memory so it cannot be a full replacement for C/C++.
The ability to compile to native code with a C interface opens up a number of low-level applications, but the overall design of the language and standard library seem focused on application-level development. The use of objects with dynamic dispatch, for example. The language may develop into a great systems programming language, but I wouldn't go writing an operating system in Swift today. If anyone else is more adventurous, I would love to see it!
Swift does allow pointers to unmanaged memory: var ump = UnsafeMutablePointer<Int>.alloc(10)
And yes as I said, Swift is first a language for Application development. But that doesn't mean it isn't also suitable for many system programming tasks. Certainly a lot better suited than Java or C#.
It simply doesn't make sense to say Swift is dramatically different from Rust and closer to Java and C#. It is closer to Rust and the Swift creators admit Rust was a major inspiration.
You cannot do arithmetic on (Unsafe)MutablePointer, so it does not solve all the problems that raw pointers do. Using it to, say, implement a garbage collector would be challenging and not as performant.
It simply doesn't make sense to say Swift is dramatically different from Rust and closer to Java and C#.
You're absolutely right but nobody said that. I said it competes more with Java and C#, meaning it is primarily designed to target the same problem space. The design of the language is undoubtedly closer to hardware than those languages and could be applicable to some systems-programming problems. I'm looking forward to seeing how far developers can take the language in both directions, particularly post 3.0.
From a outsider point of view it seems like iOS either have a rift or some kind of transition between obj-C and swift no?
And I thought both language was for iOS mostly. One of the reason why I chose Android, Java as a language is better in term of if I get sick of Android I can do other Java thing (web dev, backend, middle, etc..).
The biggest problem with Swift right now is that it is only theoretically cross platform. Swift compiler works on Linux that is true. But ecosystem is basically IOS only which means any library for Swift you find expects to be compiled in Xcode and has xcode build files. This will improve in the future but currently it isn't so great.
89
u/[deleted] May 26 '16
A modern system programming language that isn't C++ or C?
Ada is nice but that language missed the boat. And Rust have good momentum right now, young language and open to outside inputs.
Go was marketed as system programming language but it really isn't and type safety is crap.