Swift is open source, what are the benefits?

Swift is open source, great news that makes you cry!

Swift's official website is https://swift.org
Swift is available on GitHub at https://github.com/apple/swift

This morning, Mr. J asked me, what are the benefits of Swift being open source?
I would like to answer him from the following aspects:

1. Learning Swift is more convenient and simpler

When learning Swift, if you encounter problems or have some ideas, you can open the source code of Swift for reference. I believe you will gain a lot.

For example, let’s take a look at the definition and implementation of the Bool type in Swift. Is it helpful for you to customize a type?

 public struct Bool {
  internal var _value: Builtin.Int1 
 
 /// Default-initialize Boolean value to `false`.  
 @_transparent  
 public init() {
 let zero: Int8 = 0  
    self._value = Builtin.trunc_Int8_Int1(zero._value)
 } 
 
 @_transparent  
  internal init(_ v: Builtin.Int1) { self._value = v }
 } 
 
 extension Bool : _BuiltinBooleanLiteralConvertible, BooleanLiteralConvertible {
 @_transparent  
 public init(_builtinBooleanLiteral value: Builtin.Int1) {
 self._value = value
 } 
 
 /// Create an instance initialized to `value`.  
 @_transparent  
 public init(booleanLiteral value: Bool) {
 self = value
 }
 } 
 
 extension Bool : BooleanType {
 @_transparent  
 @warn_unused_result  
 public func _getBuiltinLogicValue() -> Builtin.Int1 {
 return _value
 } 
 
 /// Identical to `self`.  
 @_transparent   public var boolValue: Bool { return self } 
 
 /// Construct an instance representing the same logical value as  
 /// `value`.  
 public init<T : BooleanType>(_ value: T) {
 self = value.boolValue
 }
 } 
 
 extension Bool : CustomStringConvertible {
 /// A textual representation of `self`.  
 public var description: String {
 return self ? "true" : "false"  
 }
 } 
 
 // This is a magic entrypoint known to the compiler.  
 @_transparent  
 public   // COMPILER_INTRINSIC  
 func _getBool(v: Builtin.Int1) -> Bool { return Bool(v) } 
 
 @_transparent  
 extension Bool : Equatable, Hashable {
 /// The hash value.  
 ///  
 /// **Axiom:** `x == y` implies `x.hashValue == y.hashValue`.  
 ///  
 /// - Note: the hash value is not guaranteed to be stable across  
 /// different invocations of the same program. Do not persist the  
 /// hash value across program runs.  
 public var hashValue: Int {
 return self ? 1 : 0  
 }
 } 
 
 //===-----------------------------------------------------------------------------===//  
 // Operators  
 //===-----------------------------------------------------------------------------===//   
 
 // Unary logical complement.  
 @_transparent  
 @warn_unused_result  
 public prefix func !(a: Bool) -> Bool {
 return Bool(Builtin.xor_Int1(a._value, true ._value))
 } 
 
 @_transparent  
 @warn_unused_result  
 public func ==(lhs: Bool, rhs: Bool) -> Bool {
 return Bool(Builtin.cmp_eq_Int1(lhs._value, rhs._value))
 }

2. Swift will become more complete

Less than a day after Swift was open sourced, the Swift project received 13,087 stars and 1,351 forks on GitHub. And it is still growing rapidly...

This shows that many developers are very interested in and enthusiastic about the Swift language, and developers around the world will contribute their code and strength to Swift. Please see the following picture for yourself:

Swift data on GitHub.png

3. Swift is more powerful and has a wider range of applications

Currently, Swift supports not only iOS, OS X, watchOS, and tvOS, but also Linux platforms.

New Platforms
We can't wait to see the new places we can bring Swift—together. We truly believe that this language that we love can make software safer, faster, and easier to maintain. We'd love your help to bring Swift to even more computing platforms.

Apple supports everyone to port Swift to other platforms. In the future, there will definitely be capable developers who will use Swift on other new platforms.

My level is limited, I just express my superficial views. If you have different ideas, please comment below to discuss, thank you!