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 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

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.

idk if clojure has really faded though. some dialects have done well (jvm, js) and some haven’t gotten much use (go, clr), but it feels like a reasonable path. there’s a good chance you can tap into a decent chunk of the existing clj ecosystem too

yeah fair enough. that wasn’t really my point and I wasn’t paying attention

yeah it’s incorrect bc it destroys multibyte characters, but no idea what you’re saying about u8 being a different type from unicode. the original code was reading bytes and converting them too? the typing isn’t the issue, you can still store utf8 as a series of bytes

for some people it’s nice to start from nothing and build up config, I’d recommend doom for anyone else. it’s nice to be given a file with all the settings you can change instead of having to do it all yourself.

gitea has had some organizational problems so a lot of people have been using forgejo instead, which is just a community fork of gitea plus some more features

well the language server plugins all run a binary language server out of sandbox so zed doesn’t really do anything safer in particular there either. no ide has solutions, solutions don’t really exist right now. it’s not a problem of features of the language as much as it is features developers expect in extensions. I suppose there is a hypothetical “the extension wants to make this change to this file, approve” type flow like AI tools have now, but that sounds unpleasant to use. it still doesn’t get around things like language servers being designed to run as standalone processes out of sandbox.

by audits I meant you individually go and read all the code of all the extensions you use. of course that’s impossible too, but that was my point

I can’t imagine a sandbox would help. what can an an extension do that doesn’t touch some arbitrary code that gets run? it could add a line to the middle of a giant file right before you run and remove it immediately after. even if you run the whole editor in a sandbox you do eventually deploy that code somewhere, it can change something inconspicuous like a url in a dependency file that might not get caught in a pr

the only solution is to audit everything you install, know all the code you run, etc. ofc that’s not reasonable, but idk what else there is. better automated virus check things maybe? identity verification for extension publishers? idk if there’s an actual solution

not sure what you’re talking about but there’s two things here.

TRAMP is great and you can run the lsp on the remote machine without installing anything assuming the linters and lsp are already installed. for comparison, vscode remote downloads and runs a shim thing when you connect.

I use doom emacs at work for large codebases all the time and haven’t run into any problems. why does it only work for really small projects?

yeah that should just be a pip package instead, then install it any normal way

json is fine as a serialization format for things that need to be text, but it’s not great as something that gets edited by hand.

not that I enjoy xml, but writing long strings in json is even worse. xml I can write multiline strings as a first class entity.

I can add a comment to an xml document, json I have to write something hacky like "//": "my comment" and hope whatever is consuming it doesn’t care.

there’s just as many problems with json parsers, since most but not all of them treat numbers as js numbers, which are basically floats. you can’t rely on an arbitrary consumer having support to parse ints above a certain size so you just have to make everything a string and hope.

json allows duplicate keys, but they get overridden by the last occurrence. you can’t round trip json without losing something. you can’t rely on just seeing a key value in json text and that being correct since there could be another later. doesn’t come up often but it’s there.

this, evil is the real 4th generation vi

this is neat but also is a closed source extension. I use https://github.com/Wilfred/difftastic which doesn’t do quite as much and doesn’t integrate outside of git’s diff, but is still significantly better than nothing

that’s not a one letter template literal, that’s built in python syntax. it only has combinations of u r and f and no user defined option. f makes it templated

just stick a verification task in ci. if I have to check if the format matches the standard in a code review instead of reviewing meaningful things my time is being wasted

or if you really wanted qt, using java qt bindings: https://github.com/OmixVisualization/qtjambi