rileymichael

this is what we do internally at $dayJob. the gradle java-test-fixtures plugin (https://docs.gradle.org/current/userguide/java_testing.html#...) creates a dedicated source set and wires up artifact publishing with a `test-fixtures` classifier. consuming a libraries fixtures is as simple as:

    // pull in some-library
    implementation("some-library-coordinates")
    
    // use its provided fixtures in tests
    testImplementation(testFixtures("some-library-coordinates"))

wish it was more common in the ecosystem, but it seems most folks aren't aware of it.

> Which isn't a problem with VSCode

you also have to install plugins in vscode

> And it's free

not relevant to my comment

you can install nearly all of their supported language plugins in your editor fyi. you just lose some of the language specific integrations if you use the python plugin via intellij for example.

of course — that’s what they’re trained on after all. most treat tests as a burden / afterthought, propagating the same issues from codebase to codebase, never improving. i wouldn’t consider those good either.

except they are not good at it. the unit tests you'll have written will be filled with (slow) mocks with tautological assertions, create no reusable test fixtures, etc.

> Don't you think software engineers have a vested interest in their jobs being relevant

virtually everyone has a vested interest in their jobs being relevant

> just with less information

i'm not sure how someone who has no relevant background / experience could possibly have more information on what it entails than folks _actively holding the job_ (and they're not the ones making outlandish claims)

gee, I wonder why the guy with an enormous vested interest in pushing this narrative would say that?

in general, the people saying this sort of thing are not / have never been engineers and thus have no clue what the job _actually_ involves. seems to be the case here with this person.

Awesome turn around — I’ll give it a go this week!

Oh awesome, yeah that’d work perfect then. I’d just prep beforehand and run the one-time copy.

yeah that’s not an immediate deal breaker for me, I’m essentially looking for pgdump/restore + transformations. I’ll give it a look and see how it performs

Perfect timing — I was just looking into similar tools.

If I want to do a bulk copy (say, nightly) with various transformations but not continually stream after, is that supported / a use case that’d be a good fit for your tool?

https://central.sonatype.com/ and https://mvnrepository.com/ are exactly that

How does that differ from `gradle init`?

You're right, it's not comparable. Jetbrain's code completion actually integrates with the IDE to guarantee the suggested code isn't entirely a hallucination -- for example it checks for unresolved references so that its suggestions don't reference non-existent variables/methods.

I've disabled Copilot as it produces garbage way too often. I found myself "pausing" to wait for the suggestion that I'd ultimately ignore because it was completely invalid. I've left Jetbrain's code completion on though because it's basically just a mildly "smarter" autocomplete that I'll occasionally use / I don't find myself relying on.

If you want a generic queue that can be consumed in any runtime, you can just build it directly into postgres via extensions like https://github.com/tembo-io/pgmq.

> Situations when a testing endpoint has one set of bugs not found on production and vice versa used to be so ubiquitous in mid-2000 to mid-2010s

Honestly that's still the case, at least with Adyen. At $pastJob we had a pretty robust regression suite that'd regularly run into breaking changes in their test environment (against _old_ versioned api endpoints!). We seriously questioned whether or not anyone else used them since they were never aware until we submitted tickets. This also falls apart as soon as you use any of their "special" features that require an account rep to enable, they just don't work in the sandbox.

Another pain point is that the test payment methods offered are static. You can't setup cards for specific scenarios, e.g. tokenize, successful payment, then it expires -- you can only test an expired card as a one-off.

Under "other possible future enhancements":

> Providing a mechanism in the language to assert that all types in a certain context are implicitly null-restricted, without requiring the programmer to use explicit ! symbols.

I have a hard time agreeing that exceptions (as they exist in kotlin, unchecked) are superior. There is no way to communicate (outside of docs) to callers that a function is possibly unsafe and that they should handle it.

Good callout on the stdlib `Result`, a lot of people aren't aware of the `CancellationException` issue. Another pain point is that the error is constrained to `Throwable`, which is rather obtuse for general business logic (and you're likely generating stack traces needlessly unless you disable `writableStackTrace` on your custom throwables).

I'm a fan of https://github.com/michaelbull/kotlin-result which has a fantastic API and supports monad comprehension which helps avoid the "arrowheads" from not having a built in operator.

I don't see the connection you're making between knobs that adjust runtime behavior and tooling. As an aside, "you can't just run java code" is a bit hyperbolic, plenty of people "just run" java apps and rely on the default ergonomics. The modern JVM also offers more automated options, such as ZGC which is explicitly self tuning.

They use a ton of java, they even have their own distro. In fact, they answer this question on its landing page (https://www.microsoft.com/openjdk):

> Java at Microsoft spans from Azure to Minecraft, across SQL Server to Visual Studio Code, LinkedIn and beyond! We use more Java than one can imagine.

Having little experience with k3s, how big of a workload (“nodes” aka virtual kubelets, pods, crds, etc) can you have before saturating the non-HA control plane becomes a concern?

I'd recommend setting the user agent to avoid getting blacklisted, info here: https://www.reddit.com/r/adventofcode/wiki/faqs/automation#w...

That’s exactly what I pivoted to once I realized my naive replace wouldn’t work. That sort of moment is what makes AoC feel so rewarding in my opinion.

impl fully showing the trick: https://github.com/rileymichael/aoc-2023/blob/master/src/mai...

You can set this up to work the same way with the recent abbr changes, and I believe they may add it as a default in the future.

  function last_history_item; echo $history[1]; end
  abbr -a !! --position anywhere --function last_history_item

source: https://fishshell.com/docs/current/relnotes.html#id1

It’s not immediately obvious to me how this differs from something like ansible which people have been using for years for basic deployment topologies. What am I missing?

edit: after looking a bit closer, I think it’s a bit misleading to call what this is doing “zero downtime”. as far as I can tell, your services are essentially going to be unresponsive until they start, which can be brutal for slow starting ones (and that’s assuming they start successfully)

There is a project by a RSPS community member to accumulate all caches (https://archive.openrs2.org/) by similarly asking people, pulling from other archives, etc. This is probably the best archive in the rsps scene / I'm sure they are aware of it, there are just caches nobody has.

Using VirtioFS and the new virtualization framework makes it bearable.

AWS would fall under “bare metal”, it’s vms do not support nested virtualization (whereas the other listed providers do).

The outsourced interviewing company was Karat I assume. Pretty terrible experience as you said.

They already have: https://github.com/discord/discord-api-docs/pull/3846