[–] 16 points 4 months ago*

Zig compiler project is about 600,000 lines of code - roughly the same size as Bun before the rewrite, and I'm clocking 16s to build from scratch with a clean cache, followed by 90ms for each subsequent edit with incremental compilation enabled.

That's impressive compilation performance. And so most certainly when contrasting it to Rust.

Brb, I am rewriting everything in Zig.

  • source
  • [–] 12 points 4 months ago (4 children)

    Does Deno fit your needs? It is also a drop-in replacement to a large degree, but is somewhat focused on improving the related tooling environment.

    I'm not very involved in the (non-browser) JS ecosystem, but it's my tool of choice.

  • source
  • parent
  • context
  • [–] 1 point 4 months ago*

    Usually, when CI fails, it's a flaky CI failure or that I have in fact not run it locally.

    I guess some context is missing. My build flow seems much simpler. I check the CI steps overview and step log, and then I know what's wrong. That doesn't take 20 min. More like ~3 min.

    At work, we use Jenkins and the runners are owned infrastructure. If I debug what goes wrong in the CI environment, I go into the pipeline definition, and do the calls locally, just like that, on the command line. No need for complicated environment replication beyond that. dotnet restore, dotnet build --no-restore, dotnet package --no-build, dotnet test --no-build, etc.

    If it's not CI specific, issues show up in the normal local tooling without special env prep.

  • source
  • [–] 5 points 4 months ago

    They're making good, correct arguments, but by not acknowledging and valuing understanding [partials of] your codebase, it ultimately (subjectively) reads like "too far in that direction". Maybe it makes more sense in a big enterprise setting, but I think we're talking about software development in general.

    Like many software tools, LLMs are a double-edged sword: they make it harder to construct a detailed mental theory of the software, but they allow you to build a partial theory quickly and they can help you leverage that partial theory more effectively. This is a complex tradeoff that I’m still thinking about.

    Building a theory model is simple, verifying it is not. If possible, assumption verification, automated tests verifying assumptions, manual review of coverate of tests vs assumptions and cross references are important to validate theories.

    In the end, it's always a weighing of effort, necessity, and more, and weighing factors depend on the environment.

    Other people being allowed to write code in your codebase

    I work in a small team but on a big and long-running project [ecosystem]. I'm fine with people doing stuff without me in the loop as long as I can depend on them for care, due diligence, and understanding. Even then, I often find it valuable for me and the project to be in the loop to be able to raise concerns, ensure quality and longlevity/maintainability.

    I struggle with one colleague in particular, which I can not be sure to be even surface-level correct (they often are, but at times, repeated absolutely obvious wrongdoings), who does not document their understandings intentions or thoughts, and does not seek out understanding from sources or colleagues. Ultimately, we as a team and I personally are responsible for the customer's product, so this situations is quite frustrating and tense to navigate with some inefficient reviews, concerns, and my other [more productive] tasks.

    I don't think waving away other colleagues' contributions is constructive and productive for a project and it's health, but I do try to move myself away from owning or being involved in everything, even at the cost of quality, certainty, and risk.

    I would assume even for big teams that split into local and wider teams, it's a concern you should think about and make conscious decisions about. Teams should own their products, they have to navigate and nurture how they work together, and have to continuously weigh effort and consequence.

    they pay you money to adopt their set of engineering values
    […] sometimes you have to write slow code at your job […] Maintaining a theory of the codebase is the same kind of thing.

    They certainly don't pay me to only adapt to their engineering values. This is probably again about huge companies vs smaller teams. For me, they pay me to bring my engineering values. As a lead, I ensure we have, adjust, and follow engineering values.

  • source
  • [–] 6 points 4 months ago

    My worst experiences (from the top of my head):

    Project participates in Hacktoberfest but doesn't review nor label-acknowledge PRs.

    Project takes PR commits and replaces author when "merging" into main.

    Invest a day into a 16 months open thing, create the PR, maintainer a few hours later: "I just implemented this". Probably an unfortunate coincidence, but feels like sabotage.

    Contributing to GitLab, even simple docs, became inaccessible, infeasible. When I see typos or link markup mistakes in docs I create a PR. GitLab has a whole, elaborate onboarding process with guides, ticket creation, talking about yourself, waiting for approval, etc. Then you try to edit and by necessity fork the GitLab repo, but it reaches free account repo limits which produces unclear, confusing, inaccessible issues while trying to make and submit the changes. So you learn about the separate reduced repo you can actually fork and work and submit on. So you do that. Elaborate PR description template, which I remove, because it's a simple typo/syntax fix. They ask for more or sth. I quit; I close the MR and leave.

  • source
  • [–] 22 points 4 months ago

    If it were critical I would set up an "email me on script run failure" wrap around the individual cron jobs. Simple exit code check, potentially with console output as email body is simple and useful.

  • source
  • [–] 2 points 4 months ago

    I noticed I could not restore pg dumps as expected when migrating to a new server. I had to add some parameter to pg dump so it's a better/more neutral dump or something, which was easier/able to restore. So - definitely check your backups.

    Trying the restore locally is also an option. Just to verify it works and the expected data is there.

    How important it is to verify and verify regularly depends on how much loss you're willing to accept.

    Once verified, as long as you don't do big version upgrades or automation changes, I would expect it to continue to work indefinitely. A semi regular verification still makes sense, though.

    At work I know my DB backups definitely work for other reasons, due to regular restores in non-prod.

    For side projects I definitely recommend verifying it at least once, when setting up automated backups/scripts for backup creation.

  • source
  • view more: ‹ prev next ›