[sdegutis]

Typesafe HTTP implementation? Meh. I go back and forth on stringly typed vs strong typing. Just this weekend I wrote an app in Objective-C instead of Swift, and it's already close enough to 1.0 that I can start using it myself. I originally tried to do it in Swift but the IDE support is just way too lacking and buggy (still!) compared to ObjC. Point being, string-typing and dynamic typing aren't really all that terrible as I keep thinking they are. It gets the job done. Sure, something will always be better. But I've given up at aiming at perfectionism in programming. There's no such thing as The Perfect Language / Paradigm / Type System / etc.(TM). I'm too old and tired to keep chasing that rainbow. Pretty sure the pot of gold's in front of me all along and I keep just not noticing it and tripping over it.

[icholy]

> But I've given up at aiming at perfectionism in programming.

Optional typing is the sweet spot.

[mirekrusin]

I agree, the next missing bit is runtime structural typing (not optional of course) that allows constructs like:

```

const whatIsFoo = match (foo) {

  case : nil : "nothing, really"

  case : string : "it's a string"

  case : number | boolean : "it's bool or number"

  case [ head, ...tail ] : string[] : `it's array of strings with head ${head} and tail ${tail.join(', ')}` 

  case { value } : { type: 'NodeFoo' } : `it's Node Foo with value ${value}`

  default: "well, something else."

}

```

[bandrami]

If only there were a decades-old system that allowed that[1]

1: https://en.wikipedia.org/wiki/Common_Lisp_Object_System

[sdegutis]

It kind of already feels like that's what Objective-C is. You can use pretty-strong types, or you can just cast to id. Same with NSArray, elements can either be id (default) or a specific type. I just kind of feel like using better type systems hasn't actually helped me write better/cleaner/safer code. It's just added a very small amount of confidence and sometimes convoluted my code disproportionately.

[mirekrusin]

Objective-C doesn't have algebraic data types.

Optional, structural algebraic type system with runtime support (mainly for `match ...` constructs) is IMHO the sweet spot.

It really makes a difference to have it. The analogy on top of my head is this: it's like a difference, when working on text processing code, to have regexp or do things by hand. Similar to regexps, above type system support, can cut necessary code by orders of magnitude and make it much more readable/reason about.

[Retra]

This seems to me to be a needlessly synchronic perspective. What you're not looking for anymore doesn't exist because we haven't built it yet. How many thousands of years did it take to invent most other modern tools? Why would you expect us to have perfection in such a short time after computers have been invented?

Quit looking for pots of gold and start panning for nuggets.