6 ms·
The problem is those are subjective axes. And things can both delight and horrify; I wrote some javascript once where I did document.write = function ... which
by toast0 3y ago
The problem is those are subjective axes. And things can both delight and horrify; I wrote some javascript once where I did document.write = function ... which is kind of delightful in that I was able to do what I needed as a result, but also pretty horrifying :)
Other people I showed it to felt it was more on the horrifying side, but like I said, it's subjective.
- shagie 3y agoThen a 3d chart with "likelihood of" being a point or region in the space. The axises would then be "Surprise", "Delight", and "Horrify".
- dkarl 3y agoContext is critical. Unless you're a beginner with the language, surprise in a production codebase is horrifying. The Perl philosophy has never been compatible with lack of surprise. Perl wants to be like natural language, and natural language has limitless surprises. The problem with Perl (or, I assume, Raku) in production is that the responsible way to read it is like reading every single footnote in an annotated edition of Shakespeare. It sucks the joy out of it, and joy is the point. Production Perl is joyless and therefore pointless, unless you're some kind of prodigy who understands every obscure political reference and every 16th century pun without any help.
- Dylan16807 3y ago> Context is critical. Unless you're a beginner with the language, surprise in a production codebase is horrifying. Why? Are you assuming a very particular kind of surprise here? "Oh, I can replace these five lines with a single builtin." is a surprise, and so is seeing that someone else already did so.
- silisili 3y agoI was thinking axes of 'readability' and 'expressiveness' would make a nice chart for programming languages.
- fuzztester 3y agoAs long as the negative sides of both axes are included too. e | | | -r ------------- r | | | -e
- fuzztester 3y agoFilling in language names is left as a fun exercise for the reader.
- silisili 3y agoPython top right, Go bottom right, Brainfuck bottom left, Rust or Perl top left. (Don't kill me fanatics)
- Dylan16807 3y agoDo you think many people would put Rust and Perl next to each other?
- silisili 3y agoIn this chart, sure. Not like, the same dot, but both in that quadrant. But those are my personal opinions, as I find both difficult to read yet very expressive. YMMV.
- Dylan16807 3y agoInteresting. I haven't heard anyone complain that Rust is harder to read than the average language, just stuff about writing it.
- NikkiA 3y agoSome of the dewrapping constructs can get a bit gnarly looking when there is something wrapped in a wrapper in a wrapper sort of thing. But it's probably largely author-dependant and you could write the same code more readably.
- resonious 3y agoThis is true. Often times it's simple, stuff I wrote: delightful. stuff other people wrote: horrifying.
- throwaway2037 3y agoThis was early Perl code for me (early 2000s). Write once; read never. Once you and your teammates developed some discipline, it got much better.
- librasteve 3y agoI think that this is the crux of the story for raku ... if you want you language to apply a standard discipline, then use Python: if you are happy with your team developing a dialect that balances usability with discipline, then try Raku
- throwaway2037 3y agoif you want you language to apply a standard discipline, then use Python Wow, I hear this stuff all the time about Python. It is a myth. I have worked on multiple 500K+ line Python projects. All of them decay into a total mess due to weak typing. You can type hint until you are blue in the face, but it is never enough if it isn't guaranteed by a compiler or at runtime. So many times, I am 29-levels deep in a call stack, looking at a local variable that is incorrect typed, thinking to myself: "Oh fuck, this again." Yes, I will get 8,000 downvotes for that comment, but it does not detract from my personal experience. It takes super human talent to fight that trend. Have you seen what Dropbox did with that Finnish dude who got a PhD literally studying how to make Python more type safe with static analysis? Jesus fuckin' Christ: Amazing work, but it would be much easier to pick a different language for something that will grow to millions of lines of code! And, sadly, I write that sentence as an unashamed Python fan-boi. I truly wish there was some kind of "strict-er typed" Python mode -- or something.
- raiph 3y ago> I have worked on multiple 500K+ line Python projects. There were already several 1M+ Perl LoC code bases by the end of the 1990s, as Perl use exploded at places like Amazon. One key driver of Raku's design was making it easy to write large, clean, readable code bases, and easy to enforce coding policies if and when a dev team leader chose to. (Of course, as with any PL, you can write messy unreadable code -- and you can even write articles and record videos that make it seem like a given PL is only for Gremlins. But it's so easy to write clean readable code, why wouldn't you do that instead?) > type hint ... is never enough if it isn't guaranteed by a compiler or at runtime Indeed. Type hints are a band aid. Raku doesn't do hints. Raku does static first gradual typing.[1] The "static first" means static typing is the foundation. The "gradual typing" means you don't have to explicitly specify types, but if you do types, they're always enforced. Enforcement is at compile time if the compiler's static analysis is good enough, and otherwise at run time at the latest. For example, in the Gremlins article only one example uses a static type (`Int`). But user code can and routinely does include types, and they are enforced. For example: sub double(Int $x) { $x * 2 } double '42' results in a compile time error: SORRY! Error while compiling ... Calling double(Str) will never work with declared signature (Int $x) (Int $x) > total mess due to weak typing I know what you mean, but to be usefully pedantic, the CS meaning of "weak typing" can be fully consistent with excellent typing discipline. Let me demonstrate with Raku: sub date-range(Date $from, Date $to) { $from..$to } The subroutine (function) declaration is strongly typed. So this code... say date-range '2000-01-01', '2023-08-21'; ...fails at compile time. But it passes and works at run time if the function declaration is changed to: sub date-range(Date() $from, Date() $to) { $from..$to } (I've changed the type constraints from `Date` to `Date()`.) The changed declaration works because I've changed the function to be weakly typed, and the `Date` type happens to declare an ISO 8601 date string format coercion. But what if you wanted to insist that the argument is of a particular type, not one that just so happens to have a `Date` coercion? You can tighten things up... sub date-range(Date(Str) $from, Date(Str) $to) { $from..$to } ...and now the argument has to already be a `Date` (or sub-class thereof), or, if not, a `Str` (Raku's standard boxed string type), or sub-class thereof, that successfully coerces according to `Date`'s ISO 8601 coercion for `Str`s.