Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

Swift: When Unused Code Is a Bug

peripheryapp.com

Post reply on HN
Print view View original

11–20 of 77 posts

Re: Swift: When Unused Code Is a Bug

#11

Post by iforgotpassword »

untog wrote: post #7

I'm a little undecided on Swift extensions as a whole, and particularly protocol extensions. Maybe I'm just paranoid but it feels like it leads to a more complicated code layout.

I agree. I never worked with swift and had to look up the terminology. Most of what the article refers to maps to terms from C++ (which is already horribly complicated and offers way too many ways to shoot yourself in the foot) or Java. That PWT sounds an awful lot like a vtable. In C++ you mess up by forgetting to add "virtual" (luckily we recently got "override"), but it seems swift's protocols add another dimension to make it possible to mess up in.

It's weird how people preach over and over how arcane and cumbersome old languages like C(++) are, with the neckbeards defending it with "well you just have to adhere to this list of best practices and it's absolutely fine", and then when some new and hip language comes along and offers just as many traps, the same people giving the "old languages" crap suddenly go all "well it's bad design to do that! Just adhere to this list of best practices here..."

Re: Swift: When Unused Code Is a Bug

#12

Post by anon180719 »

joeblau wrote: post #8
anon180719 wrote: post #5

Earlier quoted context omitted.

It appears the correct action would have been to use override func greet() { print("sup") } . To be fair, I was primed to really think about the code execution given he'd indicated there was a trap in there somewhere, so it certainly would not have been immediately obvious on first glance. But I think, generally developers understand that override is necessary to override code from a parent class. Typically XCode hel…

> It appears the correct action would have been to use override func greet() { print("sup") } . That actually doesn't work because the greet function is implemented on an extension. You can only override class functions.

Oh, that's definitely weird then. Is there an RFC to have that fixed in some way?

Re: Swift: When Unused Code Is a Bug

#13

Post by joeblau »

anon180719 wrote: post #12
joeblau wrote: post #8

Earlier quoted context omitted.

> It appears the correct action would have been to use override func greet() { print("sup") } . That actually doesn't work because the greet function is implemented on an extension. You can only override class functions.

Oh, that's definitely weird then. Is there an RFC to have that fixed in some way?

I don't think there is. I think the code is functioning as expected — it's just written in a super confusing way. What should probably happen is that the compiler should throw an error about redefining a function in a super classes extension. I'm not a compiler engineer but a check for that seems like it would be intensive unless that information is codified in the AST somehow.

Re: Swift: When Unused Code Is a Bug

#14

Post by jordansmithnz »

In general I’ve found protocol extensions to be an incredibly powerful concept. There’s a couple of WWDC talks about ‘protocol oriented programming’ that highlight some great, practical use cases.

I’ve run into the author’s problem a few times, and I’d like to think that this is just a bug or behaviour detail that a future Swift version could correct. Swift hasn’t quite matured fully yet, and this is a great example of that (these examples are becoming fewer every year though).

Re: Swift: When Unused Code Is a Bug

#15

Post by kitsunesoba »

Interesting. Swift has been my primary language for a couple of years now, but I’ve never run into this, mainly because I use subclasses far, far less often than I did under Objective-C. If this bug had existed in Obj-C back when It was still my primary language it likely would have bitten me.

Re: Swift: When Unused Code Is a Bug

#16

Post by derefr »

joeblau wrote: post #9

If I saw this in a code review, I would flag it for re-design. Mixing composition and inheritance especially in this way is definitely going to confuse anyone who doesn't read every line to figure out what's going on.

I don't think there's anything wrong with mixing composition and inheritance per se, if everything is obeying strict OOP principles (Open-Closed, etc.) If the mix-in was adding functionality to the base class, and then the subclass was there to specialize the behavior of the base class without breaking any of the contracts the base class itself makes (i.e. any unit test that works on a Greeter should work on a LazyGreeter) then I don't think anyone would be confused.

But in this case, OOP principles aren't being followed—the subclass is attempting to override stuff from the protocol, which the superclass didn't override. Essentially, the superclass made an assertion, by not overriding that method, that it wanted the default behavior from the protocol extension. The subclass, by overriding that behavior, is breaking the contract that the superclass declares.

Re: Swift: When Unused Code Is a Bug

#17

Post by otaviokz »

iforgotpassword wrote: post #11
untog wrote: post #7

I'm a little undecided on Swift extensions as a whole, and particularly protocol extensions. Maybe I'm just paranoid but it feels like it leads to a more complicated code layout.

I agree. I never worked with swift and had to look up the terminology. Most of what the article refers to maps to terms from C++ (which is already horribly complicated and offers way too many ways to shoot yourself in the foot) or Java. That PWT sounds an awful lot like a vtable. In C++ you mess up by forgetting to add "virtual" (luckily we recently got "override"), but it seems swift's protocols add another dimensio…

As someone who transitioned from Java to C#/.Net to Objective-C and finally to Swift, AMEN TO THAT!

I learned not to say anything as apparently every software engineer "generation" needs to follow something "hip" when very young. Some will grow to see the cycle as it repeats itself in front of them, others will die believing "my programming language was the best, you just had to stick to this list of best practices".

Also, "bad design" quite often means "not the way I'm used to and feel comfortable with".

Re: Swift: When Unused Code Is a Bug

#18

Post by otaviokz »

Chazprime wrote: post #6

I've run afoul of this a couple of times in my Swift delegate protocols. A really nice hack to implement Objective-C's optional protocol methods in Swift is to use a protocol extension to create a default method that can come back to bite you when you subclass objects that conform to that protocol.

Yep, the old `fatalError("You need to implement this!")`.

Re: Swift: When Unused Code Is a Bug

#19

Post by mpweiher »

Wow, Heisen-Swift, where the Heisenbugs are in the language specification!

What an object is, which is roughly equivalent to its observed behavior, should never depend on how it is declared.

   let greeter = LazyGreeter()
   let greeter1: Greeter = greeter
   print(greeter)
   print(greeter1)
   greeter.greet()
   greeter1.greet()
UPDATE: just in case it's not clear, this prints the following:

   greeter.LazyGreeter
   greeter.LazyGreeter
   sup
   Hello, World!
So the same object responds differently to the same message, depending on how it is declared. Yikes!

Re: Swift: When Unused Code Is a Bug

#20

Post by wool_gather »

iforgotpassword wrote: post #11
untog wrote: post #7

I'm a little undecided on Swift extensions as a whole, and particularly protocol extensions. Maybe I'm just paranoid but it feels like it leads to a more complicated code layout.

I agree. I never worked with swift and had to look up the terminology. Most of what the article refers to maps to terms from C++ (which is already horribly complicated and offers way too many ways to shoot yourself in the foot) or Java. That PWT sounds an awful lot like a vtable. In C++ you mess up by forgetting to add "virtual" (luckily we recently got "override"), but it seems swift's protocols add another dimensio…

> That PWT sounds an awful lot like a vtable

Correct; it's the same thing in essence.

Post reply on HN