#Gamelab2018 - Jon Blow's Design decisions on creating Jai a new language for game programmers

This video does a great job of explaining why modern programming in general has failed: ▶ this video I think OOP specifically derailed programming because of how big it was, how fast it took over and how long it was considered to be the one true programming paradigm. When OOP hit, it hit hard and fast. It wasn't long before colleges were teaching OOP as The One True Way To Program. Every employer required knowledge of OOP before they would interview you. And I mean every employer, from startups to corporate enterprise. And once it took hold, it took people (and me!) 10-20 years to realize the OOP emperor had no clothes on. I still don't understand why or how it got so big so quickly. All I can figure is that the software industry as a whole pays attention to the wrong people.

in “Becoming a Better Software Developer: A Handbook on Personal Performance” · View on HN

Hubris. "Look at us, we have these LANGUAGE EXPERTS working for us". As a result the only presentations these people do are about how great their new Yet Another Language toy is. Compare this to, say, Jonathan Blow talking about design decisions for his language: ▶ this video

in “Type system of Fortnite's Verse language” · View on HN

They become really frustrating as the project grows in size. Personally, it becomes really difficult to maintain productivity. As compile times tick up, I start bouncing over to other tabs rather than just twiddling my thumbs starring at a terminal. Then I realize I've been on Reddit for a half-hour. I recently watched this talk by Johnathan Blow[0] where he talks about quality of life in programming languages and spends a fair amount of time talking about compile times and their effects. I think we collectively need to re-align on being performance focused. Tools are simultaneously amazing but crummy at the same time. [0] ▶ this video

in “Deno will stop using TypeScript” · View on HN

I happened to have read many of VPRI’s papers and some domain expertise in a few of their topics, or know close friends with such domain expertise. Btw, my collection of their links are at [link] The goal is a noble one; though it's unclear to me if their research is the right way to go. Alan Kay's gang's research's end result are often great, but their implementations are usually more geared toward prototyping rather than production. For example, the GUI innovation is great, whereas its implementation using Smalltalk is clearly geared toward faster iteration and not meant to be as competitive as a production language (let's not enter into this debate as this is another rabbit hole. Plenty of other HN threads on this). But I think so far these implementations have gotten a pass because the end result is futuristic enough for someone else to come along and implement e.g. the GUI in more production-oriented languages. In the context of VPRI, however, the goal wasn't to create more futuristic end results, but to recreate existing result using hopefully drastically more concise paradigms and DSLs. In this case, the implementation itself is the thing we should examine, and imo they kinda fall short. For example: - Yes, it's very appealing that Nile can reduce the antialiasing logic by so much. Is it resilient to real world requirement changes though? Unclear (and the Nile paper still isn't out as the author seems busy with some startup). - The OMeta parser tool is cool until you e

in “Code Budgets” · View on HN