Skip Navigation

InitialsDiceBearhttps://github.com/dicebear/dicebearhttps://creativecommons.org/publicdomain/zero/1.0/„Initials” (https://github.com/dicebear/dicebear) by „DiceBear”, licensed under „CC0 1.0” (https://creativecommons.org/publicdomain/zero/1.0/)B

BatmanAoD

@ BatmanAoD @programming.dev

Posts
2
Comments
242
Joined
2 yr. ago

  • Whatever 'Clean Code' you write now, it'll be shit eventually and in need of a complete rewrite

    Jump

  • Whatever 'Clean Code' you write now, it'll be shit eventually and in need of a complete rewrite

    Jump

  • The problem is that most languages with exceptions treat that as the idiomatic error mechanism. So checked exceptions were invented, essentially, to do exactly what you say: add the exception type to the function signature.

    Having separate errors-as-return-values and unwinding-for-emergencies is a much more recent trend (and, IMO, an obviously good development).

  • Whatever 'Clean Code' you write now, it'll be shit eventually and in need of a complete rewrite

    Jump

  • Yes. True. But Uncle Bob literally complains about non-nullable types in the linked blog post.

    I'm not saying testing isn't important. I'm saying that hand-written unit tests are not the end-all be-all of software quality, and that Uncle Bob explicitly believes they are.

  • Whatever 'Clean Code' you write now, it'll be shit eventually and in need of a complete rewrite

    Jump

  • The blog post? Yeah, that was the moment I lost most of my remaining respect for his tech opinions.

  • Whatever 'Clean Code' you write now, it'll be shit eventually and in need of a complete rewrite

    Jump

  • Unlikely, unless his view has changed substantially in the last seven years: https://blog.cleancoder.com/uncle-bob/2017/01/11/TheDarkPath.html

    I think his views on how to achieve good quality software are nearly antithetical to the goals of Rust. As expressed in that blog post and in Clean Code, he thinks better discipline, particularly through writing lots and lots of explicit unit tests, is the only path to reliable software. Rust, on the other hand, is very much designed to make the compiler and other tooling bear as much of the burden of correctness as possible.

    (To be clear, I realize you're kidding. But I do think it's important to know just how at odds the TDD philosophy is from the "safe languages" philosophy.)

  • average day in NPM land

    Jump

  • True?

    Jump

  • It's not so much a problem of there being things you "can't do" in other shells or older Bash, as that it breaks existing shell scripts, which is frustrating.

  • True?

    Jump

  • Just because it doesn't matter for most users doesn't mean it isn't a real limitation. I acknowledged as much in my original comment.

  • True?

    Jump

  • Did you read the linked Q&A?

    What do you get if you run /bin/bash --version?

  • True?

    Jump

  • You get admin privileges on MacOS like a big boy. You can use bash or zsh commands in Terminal all you want.

    Cool. So try updating to a version of Bash from the last 15 years, because the pre-installed one is Bash 3, because Bash 4 and 5 are under the GPLv3 license, which Apple won't comply with.

    ...ah, no, you can't update the pre-installed Bash, because it's on a section of the file system that is read-only even with admin access. You can install Bash 5 as a separate shell, and use that as your default terminal shell, but any scripts written with the standard #!/bin/bash instead of the more flexible #!/usr/bin/env bash will still use Bash 3.

    This "handholding" (or really, a safety net) is arguably a good thing, or at least a positive tradeoff; but you can't claim it doesn't exist.

  • People that use Neovim really like Neovim | More than any other code editor, people using it want to keep using it | 2024 Stacked Overflow Developer Survey

    Jump

  • Regular vim has that (as a compile option, like most of its features).

  • rm -rf /

    Jump

  • rm - rf is the only version that makes sense, since the only reason to delete and re-clone is to recover from an unexpected .git/ state, and git rm won't remove that.

  • Implementing RFC 3339 shouldn't really be that hard...

    Jump

  • Sorry, why would you be "boned" if you have UTC time? Are you thinking of the case where the desired behavior is to preserve the local time, rather than the absolute time?

  • "No way to prevent this" say users of only language where this regularly happens - 07/01/2024

    Jump

  • I'm not totally clear on why signals are used here in the first place. Arguably most C code doesn't "need" to use signals in complex ways, either.

  • "No way to prevent this" say users of only language where this regularly happens - 07/01/2024

    Jump

  • The trope will be "old" once the mainstream view is no longer that C-style memory management is "good enough".

    That said, this particular vulnerability was primarily due to how signals work, which I understand to be kind of unavoidably terrible in any language.

  • Stop comparing programming languages

    Jump

  • Indeed, I had no idea there are multiple languages referred to as "APL".

    I feel like most people defending C++ resort to "people shouldn't use those features that way". 😅

    As far as I can tell, pointer arithmetic was not originally part of PASCAL; it's just included as an extension in many implementations, but not all. Delphi, the most common modern dialect, only has optional pointer arithmetic, and only in certain regions of the code, kind of like unsafe in Rust. There are also optional bounds checks in many (possibly most) dialects. And in any case, there are other ways in which C is unsafe.

  • Stop comparing programming languages

    Jump

  • True, but AFAIK they all sucked really bad.

    That's pure assumption and, as far as I can tell, not actually true. PASCAL was a strong contender. No language was competitive with handwritten assembly for several decades after C's invention, and there's no fundamental reason why PASCAL couldn't benefit from intense compiler optimizations just as C has.

    Here are some papers from before C "won", a more recent article about how PASCAL "lost", and a forum thread about what using PASCAL was actually like. None of them indicate a strong performance advantage for C.

  • Stop comparing programming languages

    Jump

  • I'm honestly not convinced JavaScript is good even for the front-end, because it's intentionally designed to swallow, ignore, and otherwise minimize errors; which is not helpful at all for development of any software. My point is that the only reason JavaScript is dominant in front-end development is that, prior to WASM, it was literally the only option; if that hadn't been the case, I doubt it would have become nearly so widely used.

  • Stop comparing programming languages

    Jump

  • C++11 also introduced new problems, such as the strange interaction between brace-initialization and initializer-lists (though that was partially fixed several years later), and the fairly arcane rules around move semantics with minimal compiler support (for example, it would be great if the standard required compilers to emit an error if a moved-from object were accessed).

    I know Lisp is minimal, I'm just saying that I expect there are Lisp fans who won't acknowledge (or would excuse) any shortcomings in the language, just as there are C++ fans who do the same for C++.