Belkadan

I've been following this excellent book: https://craftinginterpreters.com/ Also read this: https://belkadan.com/blog/2016/05/So-You-Want-To-Be-A-Compiler-Wizard/

Jordan Rose also has the "Swift regrets" series [0] as a retrospective on the language design of Swift. Highly recommend it if you didn't already find it when it was on the front page. [0] https://belkadan.com/blog/2021/09/Swift-Regrets/

I've heard two side the the Protobuf/streaming idea. On my first introduction, it seemed you could. But later reading leads me to believe it is only almost streamable: https://belkadan.com/blog/2023/12/Protobuf-Is-Almost-Streamable/. * I do acknowledge you qualified the question with "better".

Swift has a lot of features, but you can leave many of them alone to begin with and learn them when you need them. Low-syntax defaults work in a reasonable, streamlined way. SwiftUI will confront you with more syntactic variations than other Swift code, but that's not unusual in a DSL. Overall it's a smooth learning curve due to progressive disclosure in language features. If Swift compiled five times faster, I would want for very little. But I don't know how they'd walk back the combination of type-based overloading and implicit conversions. See: https://belkadan.com/blog/2021/08/Swift-Regret-Type-based-Overloading/…

I had seen macros to support a quasi-message-send signature from Rust (`let value = [[cls.into() numberWithUnsignedInt:42u32] stringValue];`), but never method implementations! https://belkadan.com/blog/2020/08/Objective-Rust/

I think that’s actually a positive feature of TypeScript -- a useful limitation. Reflection is generally a bad idea and it’s good to be forced to do without it. It is a bit annoying sometimes that you can’t have overloaded functions with different types, but in that case you can usually just give the overloads different names, and usually that’s better for readability anyway. (Or if you really want to, write one function and use JS reflection to do the overloading manually) (but you really don’t!) Here’s an interesting discussion of the overloading question in Swift: https://belkadan.com/blog/2021/08/Swift-Regret-Type-based-Overloading/

This is a whole series of articles, and he does address type overloading in one of them, which is maybe what you're looking for. https://belkadan.com/blog/2021/08/Swift-Regret-Type-based-Overloading/…

This introduction post to the series of swift regrets is placed somewhere in the middle of all the posts. If you want to read these, it might be easier to start here: https://belkadan.com/blog/tags/swift-regrets/

Here is a plan with more self-sufficient steps: http://belkadan.com/blog/2016/05/So-You-Want-To-Be-A-Compiler-Wizard/

The hanshq.net story is just one of three blog entries that John Regehr linked to yesterday: http://blog.regehr.org/archives/1242 The other two are: http://jbeekman.nl/blog/2015/01/nibble-sort/ http://belkadan.com/blog/2015/05/Nibblesort/

My main takeaway is that Swift is complex and tries to solve many problems. As a result it is going to frustrate almost everyone in one bit or another. I'm not an expert in the Swift Evolution process but I must praise it in terms of ease of reading. Back when I was invested in learning more about Swift, reading some proposals helped me understand it better. But I believe the Swift team/community will need to define a boundary some time in the future on what must be added or not to the language as its complexity grows. In the long run, even if a proposal makes sense, is implemented and was reviewed, it usually will also add a new thing to the language that implies in a bigger documentation and another way to code/solve a given problem. In the AnyObject dispatch regret [0], the author wrote "As I’ve mentioned many times (though not so much on this blog), Swift had to be as good as Objective-C at making most Cocoa apps, or people wouldn’t use it no matter how good the new stuff was". My first real contact with Cocoa was while learning Swift and I can imagine all the hard work that was put into it. Then SwiftUI came on together with a bunch of new features to a language that I was still getting used to. After getting frustrated with the lack of documentation (combined with the lack of knowledge about some patterns) and no clear way to solve small problems while studying it, I've decided to dive again into Objective-C to not only grasp most of in one week but also to find that…