Okay so when you use a language daily, you begin to really pick up some opinions and feelings about it that tend to really stick with you. With swift, I definitely have some of those.
Let me focus on just two… of the things that really irk me about the freaking swift language.
Number one – Casting
This is my number one gripe with the swift language. The compiler just wont shut the hell up and do what I was intending. Now I know that apple has designed the language to absolutely not allow any implicit casting, and I understand their reasons behind this, but man, you’ve taken one benefit, and added 10-fold the costs. Requiring explicit casting takes code in swift that should look extremely simple and adds about 3-4 explicit constructor-casts to it causing the code to display as bloated, confusing ill-intended crap. What really bothers me is that this is the case even for upgrading types such as assigning a float into a double. Another problem is that in the C world (all of the APIs that we work with on a daily basis) there might be 4 or 5 different integer types (int, Sint32, GLuint, etc) and multiple float types (GLfloat, float, CGFloat, etc). Casting between these in C/C++/Objc is completely harmless 99% of the time and therefore done implicitly. In swift, I have to pepper this code with constructor casts every, single, freaking time.
In C++, you could allow implicit types by overloading the constructor so that an expression such as int x = someFloat would be the same as a constructor for int that takes a float as an argument. Swift badly needs this.
For now I’ve gotten to the point where I’ve added very simple computed properties to the various types in swift to at least make some of this casting more painless. Just a few of those extensions are below.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 |
//
// CastingHelpers.swift
// Gangster Driveby
//
// Created by Mike Farrell on 10/27/14.
// Copyright (c) 2014 Mike Farrell. All rights reserved.
//
import Foundation
//swift is driving me crazy
extension Int
{
var f: Float
{
return Float(self)
}
}
extension Int32
{
var f: Float
{
return Float(self)
}
var e: GLenum
{
return GLenum(self)
}
/*func c<T: IntegerLiteralConvertible>() -> T
{
return T(integerLiteral: i)
}*/
}
extension Sint16
{
var f: Float
{
return Float(self)
}
}
extension UInt
{
var f: Float
{
return Float(self)
}
}
extension Double
{
var f: Float
{
return Float(self)
}
}
extension Float
{
var cg: CGFloat
{
return CGFloat(self)
}
} |
This makes it so that code that would have to look like
|
1 2 3 4 |
glDisable(GLEnum(GL_DEPTH_TEST))
let f: Float = 3.0
let f2 = f*Float(sin(0.5)) |
Can be…
|
1 2 3 4 |
glDisable(GL_DEPTH_TEST.e)
let f = (3.0).f
let f2 = f*sin(0.5).f |
Number two – Stability (source kit crashes)
Google swift and “sourcekit” and you’ll see, this is nowhere NEAR an actual finished language. Apple has rushed this out the door and I’m honestly sorry that I’ve decided to use it to make a game. Imagine typing code and then every half hour you get 30 seconds of a frozen spinner before ”sourcekit crashed” appears in your IDE. If you’re lucky, it’ll stop for another 5 minutes, but if you aren’t it’ll happen in a loop and you have to go delete your “ModuleCache” dir and quit and restart xcode and start working again…. until about an hour later. This is NOT how I prefer to work. I like the “idea” of swift, but its just way too unstable to use. I’m going to finish this game with it, and then probably stay away from swift for any real projects for another year or so until apple fixes this extremely annoying stability problem.
These two things may seem small, but they’re enough to waste 10 minutes of time for every hour I work on this game, and for me, that’s just completely unacceptable.
I agree. Makes me want to yell “Khaaaaaaaan” into the dark.