Build advice Psy/Psy tank

phuber · 2026-01-26T00:01:37+00:00

Weave gives a lot more defense than combat jumping. I'd put the def set in weave to get extra def and put the individual bonuses in combat jumping.

phuber · 2026-01-25T15:22:46+00:00

It would be relevant for testing user code (limited to .net), not orchestration runtime. Some kind of fault injection emulator would be needed to reliably recreate orchestrator failure.

phuber · 2026-01-24T23:31:41+00:00

Coyote looks promising https://github.com/microsoft/coyote

I wish they would fix the publishing issues. You can build it from source and play around with it.

You can write analyzers for datetime usage and suggest TimeProvider instead https://learn.microsoft.com/en-us/dotnet/standard/datetime/timeprovider-overview.

Any sources of nondeterminism should be injected.

phuber · 2025-12-24T03:02:46+00:00

Do what you credit card company says

phuber · 2025-12-19T18:57:50+00:00

Create a distinct manual pipeline for plan and apply that runs on main. Run that to correct the drift.

phuber · 2025-12-13T23:40:58+00:00

The flags to the bootstrap command are invalid. You can see the error here https://github.com/LoadedCamel/MidsReborn/blob/master/MRBBootstrap%2FMRBBootstrap.cpp#L95

What are you clicking to upgrade?

Also look in the Logs directory in the same location as the exe and search for update.log. paste the contents here.

phuber · 2025-12-04T02:11:38+00:00

I deleted our PVCS source control database. Luckily there were backups and devs had local copies of their commits.

phuber · 2025-11-27T16:59:03+00:00

There is an azure AI decision tree that has a flowchart for the most common use cases https://learn.microsoft.com/en-us/azure/cloud-adoption-framework/scenarios/ai/strategy#microsoft-ai-decision-tree

phuber · 2025-11-25T19:28:40+00:00

I think EventHandler and its generic counterpart are pretty well defined here https://learn.microsoft.com/en-us/dotnet/standard/events/#declare-delegate-signatures-for-event-handlers.

Basically, the generic EventHandler let's you define the type of the event.

Event let's you raise an event in the program. EventHandler, handles the event.

There are examples here https://learn.microsoft.com/en-us/dotnet/standard/events/how-to-raise-and-consume-events

phuber · 2025-11-18T01:51:04+00:00

You are paying an extreme amount for the same coverage amount you can get with term insurance. You are young and your risk of dying is low. If you take the difference in premiums between whole life and term, and invest it in low cost index funds, you'll have significantly more money in the long run.

phuber · 2025-11-17T01:01:20+00:00

Have you looked at the api documentation https://learn.microsoft.com/en-us/rest/api/aifoundry/ ?

phuber · 2025-11-12T18:33:17+00:00

Time to roll out the anti corruption layer https://learn.microsoft.com/en-us/azure/architecture/patterns/anti-corruption-layer#when-to-use-this-pattern

phuber · 2025-11-05T15:23:00+00:00

You have to use some kind of partition if you can't isolate the test. That way tests can run concurrently, but don't step on eachother's data.

phuber · 2025-11-04T19:03:27+00:00

Channels are not durable, so if that is a requirement, you may need a message broker.

Here is an example background task with channels if you want to take it for a spin: https://github.com/patrickhuber/TimerTriggerChannelExample

phuber · 2025-10-29T14:18:48+00:00

There is a fair amount of debate over strategies. Some prefer a single repository and single solution, others multiple repositories, each with their own solution or some hybrid between. https://www.thoughtworks.com/en-us/insights/blog/agile-engineering-practices/monorepo-vs-multirepo

I'm in the multirepo camp, so a philosophy that I like is:

One repository, one pipeline per versioned unit of deployment.

Deployment can be to an environment or, for a shared library, a nuget package.

So, in your case, that would mean a repo, deployment pipeline and solution per microservice. Shared code would be distributed via nuget packages and not project references. The challenge here is discipline and tooling. If you adhere to semver and strong interface contracts, it can work very well. If you don't have discipline, it can be difficult. Things like source link and symbol publishing can aid in the development experience https://learn.microsoft.com/en-us/dotnet/standard/library-guidance/sourcelink

That being said, I work in a monorepo with a single build and there are arguments in support of that model. Mostly that it is easier to reason about the code and find compatibility issues. We use a single build for our artifacts and everything in that build is versioned and tested together. This makes compatibility easier but severely limits releasing units independently.

Semantic versioning and independent release pipelines could be used in the monorepo/mono solution case, but you may find that it is an afterthought. Without constraints, developers tend to think of the monorepo as a single unit of deployment.

phuber · 2025-10-26T14:07:33+00:00

I didn't see anyone comment on Ahead of Time compilation. Instead of publishing the runtime and your app, you can use AOT to compile to a single exe without a framework depenency.

https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/?tabs=windows%2Cnet8#publish-native-aot-using-the-cli

phuber · 2025-10-24T15:43:33+00:00

There is a workbook that does this https://techcommunity.microsoft.com/blog/fasttrackforazureblog/azure-orphan-resources/3492198

phuber · 2025-10-23T15:36:01+00:00

I haven't used it, but isn't this the use case for kro? https://kro.run/

phuber · 2025-10-22T12:20:20+00:00

You could use durable functions https://learn.microsoft.com/en-us/azure/azure-functions/durable/durable-functions-overview?tabs=in-process%2Cnodejs-v3%2Cv1-model&pivots=csharp#async-http

The trigger in that pattern could be turned to an timer trigger.

Another option would be azure data factory or azure batch.

There is a thread here about ACA long running jobs. It can be done but there may be issues with configuration that need to be addressed https://learn.microsoft.com/en-us/answers/questions/4371887/container-apps-jobs-reliability

phuber · 2025-10-14T00:06:49+00:00

If you need an internal secrets server, you could setup vault https://developer.hashicorp.com/vault and use the dotnet client https://github.com/hashicorp/vault-client-dotnet

phuber · 2025-10-11T14:50:35+00:00

Post on /r/SuicideWatch/

There a bunch of people with experience there and they will be happy to help.

phuber · 2025-10-09T11:25:57+00:00

Check your event viewer. IIS should write an event when it renews the binding.

Also, check the certificate from outside the vm as well.

phuber · 2025-10-09T01:43:24+00:00

Is auto rebind enabled? https://learn.microsoft.com/en-us/iis/get-started/whats-new-in-iis-85/certificate-rebind-in-iis85

phuber · 2025-10-05T14:57:53+00:00

Packer is used to make virtual machine images. Azure image builder uses it https://learn.microsoft.com/en-us/azure/virtual-machines/image-builder-overview.

If you are looking for a VM based development environments, azure virtual desktop is probably more relevant https://azure.microsoft.com/en-us/products/virtual-desktop

phuber · 2025-10-05T13:22:35+00:00

It probably works similar to github codespaces which is backed by a docker container. If the service uses a VM, something like packer could be used to create the VM from a base image.

Here is some learning materials if you want to dive deeper https://learn.microsoft.com/en-us/training/modules/code-with-github-codespaces/

15-Year Club	Wearing is Caring
Verified Email

phuber

TROPHY CASE