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/)T

TehPers

@ TehPers @beehaw.org

Posts
0
Comments
458
Joined
3 yr. ago

  • Most Important Advice After 1.5yrs @Meta

    Jump

  • I usually use whatever the formatter does by default. Most are reasonable by default, and I might prefer things a different way personally, but I find that my job is easier when everyone else's code is checked by CI to conform to the formatter's style rather than being an unreadable mess of random newlines and weird mismatched indentation.

    The guideline that I follow is that if a tool doesn't enforce a rule before the code can be merged, then it's not a rule. Everyone, myself included (if I'm being particularly pressured on a feature), will overlook it at some point, whether intentional or not.

    For early returns, I think most reasonably configurable formatters support optional braces in those cases. This of course is assuming that's a thing in your language, since many don't have a concept of one-line unbraced returns (Python doesn't use braces, Rust always expects them, etc). For consistency and just to have a rule, I usually just brace them because I know everyone will if it's enforced rather than it varying person-to-person.

  • Frontend Language Feature Matrix

    Jump

  • My point is that the colors make so little sense that the only thing that makes sense is to decouple the colors from any meaning.

    This table is so lacking and flawed that I don't even know why there's so much discussion around it.

  • Frontend Language Feature Matrix

    Jump

  • As far as I can tell, the table is purely informational and not advocating for any features as being positive or negative.

    Otherwise, yeah the colors make no sense.

  • Stay Out Of My (Project) $HOME

    Jump

  • For tool configs? I'm not really sure I follow. All my source code for the project goes in src/ or some other subdirectory, and the project root is a bunch of configs, a source directory, maybe some scripts, etc. It's never really bothered me.

    What has bothered me is __pycache__ directories. Whoever decided to litter those in every source directory all over the place... let's just say I hope they learned to never do that again. I deal with enough trying to get Python to work at all (with the absolute hell it is to get imports working correctly, the random, but admittedly mostly documented, BS gotchas littered all over the standard library, packages with poor docs, no types, and every function worth calling taking **kwargs, etc). Seeing my code littered with these directories isn't something I really want to deal with as well.

    A standard for build output might make sense to me. Maybe just throw cache stuff in .cache and build output to .build (with intermediate artifacts in there as well potentially). For configs, I wouldn't really complain about it all going in .config, but it also doesn't matter much to me, and sometimes you end up having nested configs anyway in nested project dirs (thinking of eslint configs, gitignores, etc).

  • AI coders think they’re 20% faster — but they’re actually 19% slower

    Jump

  • Depends on what you need to match. Regex is just another programming language. It's more declarative than traditional languages though (it's basically pattern matching).

    Pattern matching is something I already do a lot of in my code, so regexes aren't that much different.

    Regardless, the syntax sucks. It takes some time to get familiar with it, but once you get past that, it's really simple.

  • Patterns for Modeling Overlapping Variant Data in Rust

    Jump

  • To me, it seems like this article is overemphasizing code duplication as problematic. If multiple types of searches use some of the same fields, it's okay to just copy them to each search type that uses them. This also allows each search type to be independently updated later on to add additional fields or deprecate existing fields without affecting other search types.

    Fields that should always exist together should probably be moved to a struct containing those fields, if there's some concept that encapsulates them. Paging fields, for example, that exist only on two of three variants can just live in their own struct, and those two variants can have fields of that type.

    Code duplication is only really problematic when all duplicates need to be updated together every time. That does not seem to be the case here.

  • The probability of a hash collision

    Jump

  • The distribution is super important here too. Hashing any value to zero (or h(x) = 0) is valid, but a terrible distribution. The challenge is getting real-world values hashed in a mostly uniform distribution to avoid collisions where possible.

    Still, the contents of the article are useful even outside of hashing. It should just disclaim that the width of the output isn't the only thing important in a hash function.

  • This Overly Long Variable Name Could Have Been a Comment | Jonathan's Blog

    Jump
    • Sometimes you are using language features your team is unfamiliar with.

    Had this happen before with pattern matching.

  • Writing Code Was Never The Bottleneck

    Jump

  • Because you created a first draft. Your first draft should include all that info. It isn't writing the whole doc for you lol, just making minor edits to turn it from notes into prose.

    Without that? No clue, good luck. They can usually read source files to put something together, but that's unreliable.

  • Writing Code Was Never The Bottleneck

    Jump

  • This would infuriate me to no end. It's literally the definition of a data race. All data between threads needs to either be accessed through synchronization primitives (mutexes, atomic access, etc) or needs to be immutable. For the most part, this should include fds, though concurrent writes to stderr might be less of an issue (still a good idea to lock/buffer it and stdout though to avoid garbled output).

  • Writing Code Was Never The Bottleneck

    Jump

  • The main value I found from Copilot in vscode back when it first released was its ability to recognize and continue patterns in code (like in assets, or where you might have a bunch of similar but slightly different fields in a type that are all initialized mostly the same).

    I don't use it anymore though because I found the suggestions to be annoying and distracting most of the time and got tired of hitting escape. It also got in the way of standard intellisense when all I needed was to fill in a method name. It took my focus away from thinking about the code because it would generate plausible looking lines of code and my thinking would get pulled in that direction as a result.

    With "agents" (whatever that term means these days), the article describes my feelings exactly. I spend the same amount of time verifying a solution as I would just creating the solution myself. The difference is I fully understand my own code, but I can't reach that same understanding of generated code as fast because I didn't think about writing it or how that code will solve my problem.

    Also, asking an LLM about the generated code is about as reliable as you'd expect on average, and I need it to be 100% reliable (or extremely close) if I'm going to use it to explain anything to me at all.

    Where I found these "agents" to be the most useful is expanding on documentation (markdown files and such). Create a first draft and ask it to clean it up. It still takes effort to review that it didn't start BSing something, but as long as what it generates is small and it's just editing an existing file, it's usually not too bad.

  • This Overly Long Variable Name Could Have Been a Comment | Jonathan's Blog

    Jump

  • This depends. Many languages support 1 liner aliases, whether that's using/typedef in C++, type in Rust, Python, and TS, etc.

    In other languages, it may be more difficult and not worth it, though this particular example should just use a duration type instead.

  • This Overly Long Variable Name Could Have Been a Comment | Jonathan's Blog

    Jump

  • Ah yes, one of the major questions of software development: to comment, or not to comment? This is almost as big of a question as tabs vs spaces at this point.

    Personally? I don't really care. Make the code readable to whoever needs to be able to read it. If you're working on a team, set the standard with your team. No answer is the universally correct one, nor is any answer going to be eternally the correct one.

    Regardless of whether code comments should or shouldn't exist, I'm of the opinion that doc comments should exist for functions at the very minimum. Describe preconditions, postconditions, the expected parameters (and types if needed), etc. I hate seeing undocumented **kwargs in a function, and I'll almost always block a PR on my team if I see one where the valid arguments there are not blatantly obvious from context.

  • Computer specs for compilation times?

    Jump

  • DDR5-6000/CL28 should be fine. Make sure to enable the XMP/EXPO profile in your BIOS after installing it.

    You can follow hardware reviewers like GamersNexus, LTT, HardwareUnboxed, etc if you want to stay up to date (which is what I do), or look at their content if you just want a review for a product you're looking at.

  • Computer specs for compilation times?

    Jump

  • It's less of an issue now, but there were stability issues in the early days of DDR5. Memory instability can lead to a number of issues including being unable to boot the PC (failing to post), the PC crashing suddenly during use, applications crashing or behaving strangely, etc. Usually it's a sign of memory going bad, but for DDR5 since it's still relatively young it can also be a sign that the memory is just too fast.

    Always check and verify that the RAM manufacturer has validated their RAM against your CPU.

  • Computer specs for compilation times?

    Jump

  • Air cooling is sufficient to cool most consumer processors these days. Make sure to get a good cooler though. I remember Thermalright's Peerless Assassin being well reviewed, but there may be even better (reasonably priced) options these days.

    If you don't care about price, Noctua's air coolers are overkill but expensive, or an AIO could be an option too.

    AIOs have the benefit of moving heat directly to your fans via fluid instead of heating up the case interior, but that usually doesn't matter that much, especially outside of intense gaming.

  • Computer specs for compilation times?

    Jump

  • Very few things need 64GB memory to compile, but some do. If you think you'll be compiling web browsers or clang or something, then 64GB would be the right call.

    Also, higher speeds of DDR5 can be unstable at higher capacities. If you're going with 64GB or more of DDR5, I'd stick to speeds around 6000 (or less) and not focus too much on overclocking it. If you get a kit of 2x32GB (which you should rather than getting the sticks independently), then you'll be fine. You won't benefit as much from RAM speed anyway as opposed to capacity.

  • V2 of my Anonymous, Private, Encrypted text/URL tool, with crazy strong encryption.

    Jump

  • This is why claims about security should always be backed by an audit. Someone will inevitably (rightfully) tear you a new hole if there's any gaps.

  • Announcing Rust 1.88.0 | Rust Blog

    Jump

  • Let chains are finally stable! Yay! Thanks everyone who made that happen.