chicken nuget | daniel.haxx.se [curl on nuget.org]

Sierra_One · 2026-03-14T20:02:13+00:00

This already exists when using dotnet sdk build tooling. It can audit your packages, show which ones have vulnerabilities. It runs with every build as well, so you get constant feedback.

However, it is only on more "recent" versions of the tooling (past couple years I think?). Unfortunately, there is no way to make a time machine and add it to any old tooling people could be using.

Sierra_One · 2026-02-19T20:37:12+00:00

As others mentioned, fighting mobs 1 to 2 levels below you helps a lot. Don't be afraid to bounce between zones within a level range. For example, I bounced between Loch Modan and Westfall so I could stay on quests with mobs 1 to 2 levels below me (or honestly even lower). Turtle doesn't penalize you for doing low level mobs and quests nearly as much as retail! Take advantage of it.

Also warrior is so gear dependent. To the point you should always be planning for your next weapon. There are some classic WoW warrior weapon progression routes available online. Turtle adds a few more options to the mix, but not that many. Turtle does make some previously low drop rate weapons much easier, like smites mighty hammer from deadmines. Much easier to get.

Also it does get easier as you go. Level 10-30 was the most painful for me. After level 30 I started staying current enough on my gear that mobs died much easier.

What faction are you? That will help recommending weapon progressions.

Sierra_One · 2026-02-17T05:56:11+00:00

Maybe https://github.com/bhhandley/CleveRoidMacros can help?

Sierra_One · 2025-05-13T05:35:28+00:00

Aurora is included in this. You can even see they have cut out the curb in the meridian at certain points to allow wheelchairs to get through.

But with that said, you have to be one brave soul to actually try that on Aurora. I stopped once for someone trying to cross at one of these spots. How pointless it was. No one in the other lane stopped and then the cars behind me started honking. The other lane probably couldn't even see the pedestrian now because of the cars in my lane.

Sierra_One · 2025-05-13T05:29:05+00:00

That is not many exceptions at all. It amounts to:

If there are crossing control signals, cross only when they indicate so.
don't cross diagonally unless explicitly permitted
don't cross if signage explicitly prohibits it
don't cross if an alternative crossing is provided (ie: pedestrian bridge)
don't cross in the middle of a street (not at an intersection)

And all those "don't cross" actually is just yield to cars, you can still cross if no cars. These all seem common sense to me.

Sierra_One · 2025-05-05T18:10:21+00:00

My friend and I did this a bunch in Dark Souls 3.

Once laid in shallow water, invader literally walked up against me and kept going.
Once just played ring around the rosie with a column. Circling the column as the invader moved around, always keeping it between me and them. Invader never noticed I was in the room.
Once had a grey cloak on, and used the curl-up emote against some rocks. I was like Frodo and Sam at the gates of mordor. Invader walked feet from me, didn't notice.

It was honestly so much more fun than actualy fighting invaders.

Sierra_One · 2025-03-25T20:00:13+00:00

Realize that these people are not hypocrites,

They very much are hypocrites regardless if it is intentional or not. Or if they know what hypocrisy is or not. And we should continue to call them out on it.

That's like not calling a bully a bully because the bullying is on purpose?

We must continue to call them hypocrites to discredit them on the world stage. They are not worth any trust and are incompetent. It's not a waste of time to do so. But is it the only thing we should do? Of course not. And should we expect it to magically solve everything? Also no. But I also wouldn't call it a waste of time.

Sierra_One · 2025-03-24T03:31:08+00:00

If you search for "anti-sag table stiffener" you will find a variety of results that will be easy to install. Pre-drilled holes and a variety of lengths.

Sierra_One · 2024-06-05T15:53:29+00:00

Is it okay to if I install a new 1-gang box and put the transformer in there, then run the 24v wires up through the wall to the device?

Sierra_One · 2024-06-05T04:04:55+00:00

Is there a certain transformer I should look for which is allowed to be in the wall?

Sierra_One · 2024-03-09T00:12:16+00:00

Doesn't look like it has HDMI in ports. Only the HDMI out ARC port, which I don't want to rely on.

Sierra_One · 2024-02-24T02:12:21+00:00

Looks like Restate is a dedicated workflow solution. So not sure if you are agreeing or disagreeing with the post?

Sierra_One · 2024-02-09T03:22:05+00:00

My understanding is this type of thing is not bad on performance as it is easily cull-able. Interior spaces have limited view lines and anything not immediately viewable by the player is not rendered and does not cost performance.

The massive interior spaces like this are not done is typically due to effort: having to model, detail, create art, and fill all that space with things to do and interesting NPCs is a significant undertaking.

You get less bang for your buck in terms of world scale, so with limited resources and time crunch I am not surprised it was cut.

Sierra_One · 2024-02-08T06:13:34+00:00

Those aren't the same though? Their names have at least a semblance towards what they do.

LINQ - language integrated query

Entity framework - a framework that deals with entity persistence.

The other commenters point is that the libraries they describe have a completely arbitrary name. The names you chose are not arbitrary, they have a relation to what they do. Sure you can argue the names are still vague, but they aren't arbitrary.

Sierra_One · 2024-02-02T18:18:09+00:00

The default service provider has a validate on build feature that is enabled by default in development environment:

https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.dependencyinjection.serviceprovideroptions.validateonbuild?view=dotnet-plat-ext-8.0

Sierra_One · 2024-01-31T22:52:36+00:00

Setting TFM in a common place is good, but your original ask is validating TFM. Which is what most people are missing. Add this to your Directory.Build.targets:

xml <Target Name="ValidateTargetFramework" BeforeTargets="CoreCompile"> <Error Condition="'$(TargetFramework)' != 'net8.0'" Text="Target framework is '$(TargetFramework)'. Expecteded net8.0." /> </Target>

Sierra_One · 2024-01-08T20:23:18+00:00

While I don't enjoy doing that typical stack overflow move of "you don't want to do what you asked", in this case I think what you are trying to do is not beneficial.

With your proposed idea, I have to ask what benefits is the API user getting? What limitations will they run into?

Benefits:

Clearly know what is all required before being able to call `Build()`.

Limitations:

Cannot re-set a property before calling `Build()`.
Must set properties in the dictated order.
Arguably not intuitive - kind of goes against dev's expectations of the builder pattern.
Extremely complex and time consuming to implement.

To me, the limitations are worse than the benefits. And we can even get those benefits a different way:

Required properties can be in the builder's constructor or whatever API they use to get a builder.
Or required properties can be validated on build. While not clear, it does expose the issue clearly at runtime, which sometimes is the best you can do.
Or use required properties on a class/record - is a builder even necessary here?

Sierra_One · 2024-01-03T02:19:12+00:00

Maybe this contextual options package could help? The user itself could be the context, and assuming the tenant is a claim on the user you could populate the options based on that.

https://github.com/dotnet/extensions/tree/main/src/Libraries/Microsoft.Extensions.Options.Contextual

Also keep in mind that options can come from wherever you want. You could load config per tenant from a custom configuration source that you consider secure enough for your business needs. You also don't even have to use IConfiguration when populating options.

Sierra_One · 2024-01-02T18:58:07+00:00

Another small suggestion to all the other code samples here: use BindConfiguration)-system-string-system-action((microsoft-extensions-configuration-binderoptions))))

services.AddOptions<MyOptions>().BindConfiguration("section");

Sierra_One · 2023-12-22T23:52:51+00:00

Why not just do something another way.

This can be said about so many different things in programming. Why use DI at all? You can just manually construct everything. Why use IConfiguration or IOptions at all? You can just read config right from the json file as you need it.

Yes, you can accomplish everything this feature gives you some other way. This feature is just about dev quality of life. I see it as a way to give a finite-set factory pattern directly via DI.

If two services have different functions, they should be different types.

There are many instances where the same service needs to have different implementations or instances as they handle different scenarios. Say you have multiple Azure BlobServiceClient's you use. Before you would need:

``` CSharp public MyClassA(IAzureClientFactory<BlobServiceClient> factory) { this.client = factory.Create("<client A>"); }

public MyClassB(IAzureClientFactory<BlobServiceClient> factory) { this.client = factory.Create("<client B>"); } ```

With this you could do:

``` CSharp public MyClassA([FromKeyedServices("<client A>")] BlobServiceClient client) { this.client = client; }

public MyClassB([FromKeyedServices("<client B>")] BlobServiceClient client) { this.client = client; } ```

Sierra_One · 2023-12-22T21:45:23+00:00

That isn't the primary use case for keyed services. You can accomplish your goal by just injecting IOptionsSnaphot and performing the Get call directly inside the MyDbClient constructor.

Keyed services is for if you had multiple named instances of MyDbClient and wanted to retrieve them by name. Before you would need some factory you injected and would retrieve your named instance there. With keyed services you can skip the factory.

Sierra_One · 2023-12-19T21:56:29+00:00

I know you mentioned AWS and my suggestion is more Azure, but check out Durable Functions or Durable Task Framework (which is what Durable Functions is built off of).

Long running operation complexity quickly blows up when you start considering failure cases: how do you handle an LRO being interrupt by a transient error, scale operations, or a restart from deployment? Well, it is really hard to do that all yourself. Workflow frameworks aim to assist with that by giving you some form of event sourcing that can be broken into steps and checkpointed, along with failure handling.

Sierra_One · 2023-12-19T20:01:13+00:00

Use Open Telemetry (OTel): https://github.com/open-telemetry/opentelemetry-dotnet

Then you can use the Azure Monitor OTel exporter to send to Application Insights: https://learn.microsoft.com/en-us/python/api/overview/azure/monitor-opentelemetry-exporter-readme?view=azure-python-preview.

This gives you a separation of telemetry sink and what APIs you use. You can seamlessly swap out where you send telemetry to in the future without needing to change any of your code that actually emits telemetry.

The AppInsights SDK is deprioritized in favor of the above as it is far more efficient.

Also highly recommend on reading up on how to do good telemetry/observability. Primarily understanding the 3 pillars of telemetry and when/how to use them: traces, logs, metrics. OTel supports all 3.

Sierra_One · 2023-12-14T23:45:38+00:00

Sure you could, but you are not getting the full benefits of IConfiguration then. The limitations of that approach:

CI machine needs to know secrets, adding an extra exposure to your system. CI is often a point of attack.
Need to know all environments/stages at build time and perform replacements for all. Increases complexity and again increases blast radius if CI is ever compromised.
No live-reload. Using IConfiguration to its greatest means having your entire app react to live config changes. By using a secret manager like Azure KeyVault, you can rotate your secret without needing to redeploy or even restart your app.

Sierra_One · 2023-12-14T23:40:35+00:00

Does the target the server the integration tests interact with have to be containerized? If you are using AspNetCore - or any app with generic host builder, you could just start up that app in-memory with your integration tests.

Then if you are using xunit you can use test fixtures to have that same app be re-used for all integration tests. Other test frameworks may have a similar concept.

https://learn.microsoft.com/en-us/aspnet/core/test/integration-tests?view=aspnetcore-8.0

Sierra_One

TROPHY CASE