His manager at least had the decency to warn him ahead of time about the PIP. Still - it seems mostly about forcing him out of his remote position.

If you want to level up your game, find a new job, or grow into a new role, by all means take a course or training on your own time. All of the concerns that you listed are probably worth spending dedicated time to upskill on.

If you stay in this field for much longer, you're going to run into a lot of cases where the thing you've been doing is replaced with the New Thing. The New Thing will have a couple new ideas, but will also fundamentally handle the same concerns as your Old Thing, often in similar ways. Don't spend your free time chasing the New Thing without getting something out of it - getting paid, making a project that you wanted to make anyways, contributing to New Thing open source projects.

If you sink work into the New Thing without anyone willing to pay for it, that's fine, but it means that you might never get someone to pay for it. Most companies are more than willing to hire experienced Old Thing devs on New Thing jobs, and will give you some time to skill up.

My team has just decided to make working smokes a mandatory part of merging a PR. If the smokes don't work on your branch, it doesn't merge to main. I'm somewhat conflicted - on one hand, we had frequent breaks in the smokes that developers didn't fix, including ones that represented real production issues. On the other, smokes can fail for no reason and are time consuming to run.

We use playwright, running on github actions. The default free tier runner has been awful, and we're moving to larger runners on the platform. We have a retry policy on any smokes that need to run in a step by step order, and we aggressively prune and remove smokes that frequently fail or don't test for real issues.

This is true, but it isn't good for OPs long term prospects either. Dumping a pile of money in a hole while taking on legal risk means that the losses are going to need to be made up somewhere.

I think that if you're going to pursue your masters, you're going to be putting in a tremendous amount of effort, money and time, especially if you plan to remain employed at the same time. You need to interrogate whether that's worth it to you, and whether your goals line up with what you're doing.

Will you be able to take advantage of the networking opportunities? Do you feel like there's a contribution to computer science as a field that you want to make and make official? Is there a level of rigor or precision of thought that you feel like you could gain?

It seems like what you value are hands on keyboard skills, money, and recognition from your peers. If you go through the masters program, get just a little better, and spend a lot of money, is that worth formalizing that recognition?

The overview is good, and the outline is good, but ultimately the problem is that the returns on big investments in DX are only really seen for companies at absolutely massive scale. There are far more companies that just burned through money getting a "nice" dev environment than there are companies that put a FTE or more into DX and saw worthwhile results.

It's worth some time for teams to think critically about their own tooling, but the trend towards DX as an end in and of itself has been a drag on many teams.

Cloud, and really any vendor specific stuff, is tough to keep up with both in terms of learning and creating training materials. You're better off getting it straight from amazon, google or other practitioners. See if you can find some smaller conferences in your area, and if you can spend training budget on that.

Obviously $200 isn't much, but coursera might be a better bang for your buck than some other systems. Learning core skills will help you level up, while a lot of Udemy and similar content will just keep you on the same track you would have been on.

XML would be great if it wasn't for the extended XML universe of namespaces and imports.

I've had some luck at using AI to get over the hump of the first "does this component work" test - it's easy to detect stuff that needs to be mocked and put in stub mocks using GPT. GPT is horrible at writing good tests, but often it's harder to write that first one than the meaningful tests.

I still put them in gists, with no real tooling. I pull them in selectively when I get a new machine.

Job hopping at a fixed time is silly. Don't leave a situation where you're growing, getting new opportunities and doing interesting work because generalized advice on the internet told you to. Leave when you're not happy, not growing, and not getting paid what you're worth.

The timing right now isn't great either - the market is flooded with recent layoffs, and companies are trying to pick them up at a discount.

XML to transform XML to import into more XML? Can't we just have a config file that isn't setting up some big tie in?

JSON5 is a superset of JSON that supports comments.

I think the best thing to do with TDD is pair with or convince devs to try it for a feature. Coming at things test first can be novel and interesting, and it does train you to test and use tests better. Once people have tried it, I think it broadens your use of tests pretty well.

However, TDD can be a bit of a cult, and most smart and independent people (like people willing to work at a <20 person company) will notice that TDD isn't the silver bullet it's proponents make it out to be.

Github actions is good for us, but honestly just because that's where our code is.

We use a little bit of property testing to test invariants with fuzzed data. Mutation testing seems like a neat inverse.

Get good at the three point turn.

• Add the new code path/behavior. Release - this can be a minor version in semver.
• Mark the old code path or behavior as deprecated. Release - this can be another minor version.
  • In between here, clean up any dependencies or give your users time to clean up.
• Remove the old code path or behavior. Release. If you're using semver, this is the major version change.

This is a stable way to make changes on any system that has a dependency on another platform, repository, or system. It's good practice for anything on the web, as users may have logged in or long running sessions, and it works for systems that call each other and get released on different cadences.

This is it. From another angle, setting clear boundaries on your time, delegating and trusting your team, and managing expectations are all powerful skills that need to be developed from the senior level and up. Clearly knowing and articulating your limits can lead to working on more valuable and meaningful work within those limits.

My experience with E2E testing is that the tools and methods necessary to test a complex app are flaky. Waits, checks for text or selectors and custom form field navigation all need careful balancing to make the test effective. On top of this, there is frequently a sequentiality to E2E tests that causes these failures to multiply in frequency, as you're at the mercy of not just the worst test, but the product of every test in sequence.

I agree that the tests cause less flakiness in the app itself, but I have found smokes inherently flaky in a way that unit and integration tests are not.

It's not a fully controlled environment, that is the point of smokes.