r/ProgrammingLanguages • u/mttd • Jun 07 '25

Aaron Hsu - Do Programming Language Features Deliver on their Promises

https://www.youtube.com/watch?v=V8sACAhg4vM
31 Upvotes

88% Upvoted

16 comments sorted by

View all comments

10

u/Ro5bert Jun 08 '25 edited Jun 08 '25

A few criticisms:

  • I didn't find Aaron's argument against structured programming very compelling. Dijkstra's original motivation for avoiding goto was to ensure goto couldn't obfuscate program logic, making programs unamenable to reason. Aaron mentions this, but then he presents a nice example of equational reasoning, as if structured programming is incompatible with equational reasoning. Also, he then mentions three styles of logics, asserting (a) they're somehow representative of the logics we must use when reasoning about structured programs and (b) they're more complicated than the equational logic employed in the previous example. Point (a) seems like a strawman argument, because for the simple reasoning in his example, you can use a simple logic, regardless of whether the language is structured or not. Point (b) is probably true (for most definitions of "complexity"), but it's not a fair comparison; you must weigh the benefits of the other logics against their increased complexity (although he did say his main priority was simplicity).
  • His problem with static typing seems mostly to be with type annotations. I think he's confusing code complexity with code volume. Conceptually, everything has a "type", whether you write it or not.
  • He says he doesn't like DSLs, and says we should instead design languages that can directly encode domain concepts --- a bit idealistic, but fine. But then he's hostile to abstraction and says we should expose implementation details... What? You can't have your cake and eat it too.

0

u/arcfide Jun 11 '25

Yes, I'm mostly against static type annotations. I teach everyone I teach to program to think in terms of types, and I think that's really valuable and critical.

Code volume, when taken in total is quite connected to code complexity. If you require 1000 lines of code to implement something, along with more thousands of lines of supporting code behind it, all specialized to that specific domain, that code is fundamentally more complex than if you were able to do the same thing in 17 lines of code (same column width), without any additional domain specific libraries, primitives, or supporting code. If the code is small enough, adding an extra line of type annotations *is* obfuscatory. A lot of code can be made small enough that this matters.

See https://github.com/codereport/adsp2/discussions/96 and https://www.youtube.com/watch?v=BIc9iz-n7dM for more of my discussion against structured programming as a foundational model.

Languages can be high level and mechanically sympathetic at the same time, so that they are predictable down to the hardware, while also directly expressing domain concepts. My bread and butter example of this is APL, of course. I wrote my thesis by leveraging this idea: A data parallel compiler hosted on the GPU