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
Posts
0
Comments
146
Joined
3 yr. ago

  • you can also buy a nice USB/Bluetooth dac instead of the inline ones that tend to be more fragile. better quality than an internal one and the flexibility of Bluetooth if you want it. generally a little bulky but if you already have wired headphones I don't think it's significant

  • just to be clear since you said both again in different sentences, GUID and UUID are two names for the same thing.

    I think that spec predates uuid4, it only mentions the time based/node based variants. 122 bits of auth token should be plenty, right?

    the sheer unlikeliness of guessing that large a number, the original post is fake or something else is going on.

  • I've worked at several places that didn't have formatters when I started. they did by the time I left. you can incrementally adopt them and if it's automated most people at worst don't care. advocate for things you want

    reassignment and hoisting are the significant ones. behavior around this does just seem more intuitive than otherwise when it comes up, so I think telling especially new devs to use const arrow fn everywhere but classes is a reasonable rule

    hate to break it to you but it behaves like a variable either way. function just behaves closer to a var variable. const fns are less like variables since no assignment. intellisense/devtools all show them just fine. it really is just a minor aesthetic difference on the definition

  • knowing the programming language you're working in at a basic level is gatekeeping I'm ok with

  • I'm pretty sure it can, it's just been moved to Google maps instead

  • semicolons? quotes? use a formatter and don't think about it. I think js world has basically done this already.

    const is simpler. why would I declare an array as let if I'm not reassigning? someone can look at it and know they don't have to think about reassignment of the reference, just normal mutation. ts has the further readonly to describe the other type of mutation, don't abuse let to mean that.

    const arrow over named function? gets rid of all the legacy behaviors and apis. no arguments, consistent this, and no hoisting or accidental reassignment. the 2 places you should ever use named fn are generator or if you actually need this

  • they're different files generally, the only client that will automatically request them is a debugger.

    you turn them off because you don't want to expose your full source code. if you would be ok making your webpage git repo public then making sourcemaps available is fine.

  • most things should have an alternate implementation, just in the unit tests. imo that's the main justification for most of SOLID.

    but also I've noticed that being explicit about your interfaces does produce better thought out code. if you program to an interface and limit your assumptions about implementation, you'll end up with easier to reason about code.

    the other chunk is consistency is the most important thing in a large codebase. some of these rules are followed too closely in areas, but if I'm working my way through an unfamiliar area of the code, I can assume that it is structured based on the corporate conventions.

    I'm not really an oop guy, but in an oop language I write pretty standard SOLID style code. in rust a lot of idiomatic code does follow SOLID, but the patterns are different. writing traits for everything instead of interfaces isn't any different but is pretty common

  • all of their examples are pre ai anyway. it's almost impossible to change a core data model thing without ai too.

    all the legacy codebases I've worked in have very much been shaped by the original abstractions they decided on. as much as I wanted to change them, there wasn't really a way to do so because of the scale and backwards compatibility requirements

  • some things are easier to change than others. it's easy to slop on new features, rewrite them etc. changing core models after you've built a ton on them isn't easy, even with ai. the odds it comes up with the perfect data model aren't great, but for isolated features that doesn't matter since it's easy to throw them away and rewrite

  • I do think they should have taken an approach similar to prettier and gofmt. very minimal settings and opinionated so all js/go codebases are effectively the same formatting

  • steam is one of the few commonly used 32 bit apps left on linux.

    I imagine most of it is bc most other things are oss and have been updated/rebuilt already. having to run a 10 year old binary happens way less on linux than it does windows.

    a handful of distros have tried to remove 32 but support they've gotten backlash bc they'd lose steam support. linux the kernel won't drop it any time soon, but there's a good chance that if steam drops 32 bit, so will fedora etc

  • yeah, ofc it should only be a curated set of errors where the consumer can do something about it. unknown errors should just be opaque 500s

  • I love clj. in general it takes more of a pragmatic approach to functional programming than others. you get most of the purity for way less effort. same with specs over proper static types. it just ends up being a very enjoyable and productive language

  • sql as the language executed by the db hasn't changed notably, but I do think there's been significant developments in ORMs. for a lot of developmers sql is now just an intermediate target

  • more directly, sqlite was originally for tcl which is why they share the semantics.

    also I'd argue that sqlite is a bigger contribution than tk, but I suppose in a more roundabout way

  • did you read it? apple throttled device performance. google is throttling charging speed and battery capacity for safety reasons. there are literally phones melting. also, battery capacity is something people assume will go down over time. also they're giving clear notifications when people are affected.

    it's not really the same, and definitely not worse

  • Deleted

    Permanently Deleted

    Jump
  • early js/html liked to do something in all cases instead of throwing or whatever. I think it's mostly just a collection of them trying to do something smart on nonsense input and not being consistent about it.

    side note, I'm so excited for Temporal, some browsers already support it and you can polyfill for the rest.

  • I have a GL.iNet GL-MT6000, works great. not sure about newer models but people generally seem to like their higher end ones

    it ships with almost vanilla openwrt, and it's easy to install an upstream build if you'd like. the big advantage of GL.iNet is that it's officially supported, so I've been able to send emails to support about openwrt stuff and they've been helpful

    AdGuard works great and is built in to their version, so you wouldn't even need the separate device for pihole

    I also like supporting a company that supports oss software