JB_Dev

Intent (should) be what matters. If you want to learn how to train AI and use copyrighted material in your learning - I don’t care in the slightest at all.

In fact if you do this as a nonprofit or at an educational institution in a teaching context it’s explicitly allowed by fair use already.

If you do it individually, idk I’m not a lawyer. But it should be allowed on principle.

But if you then go take your trained AI and deploy it for commercial purposes that’s a different story and should have protections for the original rights holders.

“Fair use” allows for educational usage of copyrighted material. Technically it probably is not fair use as Microsoft isn’t an educational institution or a nonprofit.

But come on … these guides really are for learning purposes. Doesn’t seem like a big deal to me at all. They aren’t even hosting it, just pointing to kaggle who is hosting it.

On principle copyright law should allow this kind of learning use case anyway.

My goto has been crt.sh for a few years

Yea agree.. This is the same discussion point that came up last time they had an incident.

I really don’t buy this requirement to always deploy state changes 100% globally immediately. Why can’t they just roll out to 1%, scaling to 100% over 5 minutes (configurable), with automated health checks and pauses? That will go along way towards reducing the impact of these regressions.

Then if they really think something is so critical that it goes everywhere immediately, then sure set the rollout to start at 100%.

Point is, design the rollout system to give you that flexibility. Routine/non-critical state changes should go through slower ramping rollouts.

Code and Config should be treated similarly. If you would use a ring based rollout, canaries, etc for safely changing your code, then any config that can have the same impact must also use safe rollout techniques.

Does their ring based rollout really truly have to be 0->100% in a few seconds?

I don’t really buy this requirement. At least make it configurable with a more reasonable default for “routine” changes. E.g. ramping to 100% over 1 hour.

As long as that ramp rate is configurable, you can retain the ability to respond fast to attacks by setting the ramp time to a few seconds if you truly think it’s needed in that moment.

You are 100% correct but really these engineers should go read the guidance - it’s pretty clear what is required: https://learn.microsoft.com/en-us/entra/identity-platform/cl...

Nah this is just microsofts quality bar in general. AI will only accelerate the decline.

100% agree. i’m not sure why everyone is clowning on them here. This process is a win. Do people want this all being hidden instead in a forked private repo?

It’s showing the actual capabilities in practice. That’s much better and way more illuminating than what normally happens with sales and marketing hype.

I actually have the opposite position on this. 1st world countries already have the funds and economy to pursue exactly what you describe. Just they lack the political will. I don’t care to subsidise that intentional lack of investment.

I would much rather give to charities focusing on countries that don’t have the economy/ability to fix their basic issues.

Call me pessimistic, but as the sidewalk pattern becomes more common for IoT, I wouldn’t be surprised if a “malfunctioning radio” just results in the device not working properly.

Make it a roundabout with protected pedestrian crossings. That forces drivers to be looking at the conflict point with pedestrians as they manoeuvre the roundabout.

If you do not wait in the intersection itself then you would never get a chance to turn in many intersections. The only solution is to always wait in the intersection itself.

Execs talk to customers all the time and so wouldn’t auto delete emails tagged external.

In an actual emergency, cell towers may not function. AM has significantly further range too and is pretty easy to standup as a backup for an area.

It’s also incredibly common for road conditions to still be shared over AM - you see this a lot while driving with all the “advisory - tune to …. AM” signs everywhere.

Eventually you get data residency asks to keep data in the right region and for that you need to have horizontal partitioning of some kind.

The time investment here doesn’t really make sense to me. That 70% savings was actually only $33 a month.

Was it really worth spending that dev time and effort for such a small return rather than the product itself?

And yea now you get to manage your own cluster… thats an ongoing cost too, not free.

This has been described as similar to Uber/Lyft surging but it’s different in a few critical ways that I suspect consumers are less tolerant of.

When Uber/Lyft are surging it incentivise more drivers to go to the surge area. This raises supply and the surge rate decreases. Drivers are distributed automatically where they are needed. Overall trips taken should be higher compared with a no surging model. So it shifts both the demand (higher ride price) and the supply curves dynamically. That’s an easier model to market to customers as there is at least some logical sense behind it.

However in Wendys case dynamic pricing has no effect on supply. It just modifies the demand curve.

Fundamentally they are betting that their food demand is inelastic enough that they’ll make more money overall. That just feels more exploitative and is going to be harder to market.

I’ve done something similar in one of our production services. There was a problem with extremely long GC pauses during Gen2 garbage collection (.NET uses a multigenerational GC design). Pauses could be many seconds long or more than a minute in extreme cases.

We found the underlying issue that caused memory pressure in the Gen2 region but the fix was to change some very fundamental aspects of the service and would need to have some significant refactoring. Since this was a legacy service (.net framework) that we were refactoring anyway to run in new .NET (5+), we decided to ignore the issue.

Instead we adjusted the GC to just never do the expensive Gen2 collections (GCLatencyMode) and moved the service to run on higher memory VMs. It would hit OOM every 3 days or so, so we just set instances to auto-restart once a day.

Then 1 year later we deployed the replacement for the legacy service and the problem was solved.

It’s pretty simple - software engineering compensation can be 2x-4x or more in the US compared to other western democracies. Money circumvents a lot of the problems you describe.

I used to agree with you until I saw this presentation by Jim Keller, one of the biggest names in chip architecture. It really illustrates how many more options we have to improve performance.

https://www.youtube.com/live/oIG9ztQw2Gc?si=vCBGGm0tkhG-VOyd

E.g. https://x.com/markrussinovich/status/1656416376125538304?s=4...

Aware

Nvidia and really all chip designers are limited by the fab companies who are trying to scale as fast as they can. But all the cutting edge fabs are limited by one single supplier - ASML. ASML make the lithography machines and have a total monopoly. Even they cannot make lithography machines fast enough to satisfy demand - their lithography machines are sold out 2 years in advance

I have been in this situation too and tried to do the ‘polite’ thing and sit somewhere else. Then of course another group comes along and I am in their spot. So now when this happens I refuse the suggestion and ask whoever is in my seat to move to their original seat. It’s the only proper solution to this problem.

You missed this critical part “you easily make enough money to…”

If you are making >$250K year, an extra $2500/month is not a significant bump. Especially as it is temporary while you are between jobs. Temporary could even be a year or longer.

Factor that cost into your emergency savings and draw down when you need to. You still end up massively ahead of a developer outside the US.

I am not endorsing the US system - it is objectively garbage. But the point is that the pay difference more than makes up for the downsides in healthcare.

Pretty much, yea. You easily make enough money to pay for COBRA. Then if that runs out you can get (an admittedly bad) plan from the marketplace. But it all comes back to point (1) - the amount you make more than makes up for it.

If my ride-sharing app charges riders half the price, I think we’ll get quite a few riders in a short amount of time. Uber won’t be able to compete.

I was sufficiently curious and just went and tested this using BenchmarkDotNet. The example code is here (https://github.com/J-Bax/CSharpBenchmarkExamples).

The difference is quite significant.

(1) With the authors code (using Task.Run), I get ~428MB of allocations.

(2) Dropping the unnecessary Task.Run(...), I get ~183MB of allocations.

(3) Doing (2) and waiting N times on the same delay, I get ~39MB of allocations.

This was all using .NET 6 too. .NET 7 or the 8 preview might be even better since they are working hard on performance in recent releases.

So even looking at just (2), that puts .NET on par with the rust library.

It looks like most of the languages are doing the same thing w.r.t using a 'List'-style implementation that re-sizes/copies it's internal buffer when it runs out of space. One thing I wonder though is whether the managed languages pay a bigger penalty on the memory usage than the unmanaged languages due to this.

In the unmanaged languages, those intermediate buffers should be freed immediately during the re-size operation.

But in the managed languages, they might stick around until the next GC. So the peak memory would be higher.

In this example the runtime overhead is going to represent more of the memory usage anyway but it quickly isn't negligible. E.g. a list of size 1M is going to be ~8MB (64 bit addresses). So even if the array is re-sized from 1->2->4->8->...->~500K, the end result is not going to be worse than 2X the size.