HN user

algorithmsRcool

1,521 karma

https://github.com/AlgorithmsAreCool

Posts36
Comments245
View on HN
github.com 1mo ago

Deterministic Implementation of a .NET Runtime

algorithmsRcool
3pts0
github.com 1mo ago

Chibil: A C compiler targeting .NET IL

algorithmsRcool
45pts5
iev.ee 4mo ago

RE#: how we built the fastest regex engine in F#

algorithmsRcool
6pts0
blog.applied-algorithms.tech 1y ago

A week with Satori, the experimental low-latency GC for .NET

algorithmsRcool
4pts0
blog.applied-algorithms.tech 1y ago

A sub-millisecond GC for .NET?

algorithmsRcool
29pts4
github.com 1y ago

Pauseless Garbage Collector

algorithmsRcool
6pts2
blog.applied-algorithms.tech 1y ago

Getting started with Dafny: Your first formal proof

algorithmsRcool
3pts0
blog.applied-algorithms.tech 1y ago

So what is Model Based Testing anyway?

algorithmsRcool
1pts0
blog.applied-algorithms.tech 1y ago

So what is Model Based Testing anyway?

algorithmsRcool
2pts0
learn.microsoft.com 1y ago

What's New in C# 13

algorithmsRcool
7pts0
github.com 2y ago

Microsoft Orleans v8.2.0

algorithmsRcool
2pts0
github.com 2y ago

Introduction to Vectorization with Vector128 and Vector256

algorithmsRcool
2pts0
github.com 2y ago

CsCheck: Random Testing Library for C#

algorithmsRcool
1pts0
learn.microsoft.com 2y ago

What's New in C# 13

algorithmsRcool
13pts2
github.com 5y ago

Hysteresis effect on threadpool hill-climbing

algorithmsRcool
2pts0
github.com 5y ago

C# Compile Time Method Execution Generator

algorithmsRcool
1pts0
github.com 5y ago

Unishox – Guaranteed Compression for Unicode Short Strings

algorithmsRcool
1pts0
github.com 7y ago

Failure Detection and Consensus in Distributed Systems with F#

algorithmsRcool
2pts0
github.com 7y ago

Failure Detection and Consensus in Distributed Systems with F#

algorithmsRcool
2pts0
github.com 7y ago

A compiler framework for managed code

algorithmsRcool
2pts0
github.com 7y ago

Trill: high-performance in-memory streaming analytics engine

algorithmsRcool
2pts0
andrewlock.net 7y ago

Why is string.GetHashCode() different each time I run my program in .NET Core?

algorithmsRcool
1pts0
github.com 7y ago

Ambrosia: Robust Distributed Programming Made Easy and Efficient

algorithmsRcool
24pts8
www.microsoft.com 8y ago

FASTER: A Concurrent Key-Value Store with In-Place Updates

algorithmsRcool
3pts0
en.wikipedia.org 8y ago

Bose–Einstein condensation (network theory)

algorithmsRcool
2pts0
docs.microsoft.com 8y ago

Microsoft SQL Operations Studio (Preview)

algorithmsRcool
5pts0
github.com 8y ago

Microsoft SQL Operations Studio Public Preview

algorithmsRcool
2pts0
github.com 8y ago

DbgShell: A PowerShell front-end for the Windows debugger engine

algorithmsRcool
1pts0
github.com 8y ago

DbgShell: A PowerShell front-end for the Windows debugger engine

algorithmsRcool
2pts0
github.com 8y ago

MemoScope.Net: Dump and analyze .Net applications memory

algorithmsRcool
2pts0

It is still a thing, just not a very common one since the debugger in VS has become more ergonomic and powerful. But windbg is still the king here, for the most advanced analysis of both managed and unmanaged code and it isn't even close to be honest once you learn the arcane commands and incatations

But why not do it right the first time. This is an obvious performance pitfall for people that want to adopt this feature. It is bizarre to me after the last decade has been dedicated to performance improvments.

Allowing hallucinated content or citations into your work is an act of carelessness and disregard for the time of people that are going to read your paper and it should be policed as such.

And flatly, if a person can't be bothered to check their damn work before uploading it, why should anyone else invest their time in reading it seriously?

Why on earth did they decide boxing by default was a sensible design decision...

We have been pushing toward higher performance for years and this is a performance pitfall for unions would are often thought of as being lighter weight than inheritance hierarchies.

F# just stores a field-per-case, with the optimization that cases with the same type are unified which is still type safe.

Well off the top of my head...

Active patterns, computation expressions, structural typing, statically resolved type parameters, explicit inlining, function composition, structural equality, custom operators and much richer generators.

The Tree of Life is singular to me as a piece of cinema, americana and a meditation on the beauty of life and especially childhood.

When I saw it the first time, I was so awestruck by the breathtaking cinematography and the incredible music, but even more so by the vision of it all. I had simply never seen anything like it.

I saw it another 4 times before it left theaters.

Like if you build an Excel formula, the mandatory async/await approach just doesn't work. It's not an asynchronous operation and runs into a UI context where you deadlock if you wait.

Last time I did excel interop it was COM based and there wasn't any async part of it. I'm curious if you were using COM interop also? Also, async/await was explicitly designed to work in UI contexts like Winforms and WPF where there is only a single UI thread...?

It took like 15 years before they added a json serializer to the standard library..

That isn't really true. DataContractJsonSerializer [0] landed in .NET 3.5 which was in 2007. Admittedly, it kinda sucked but it was there and was usable. And also JSON.Net was around by that point and was/is excellent.

...and don't even think about support for any new major image format (webp, heic).

Image support on windows was historically provided by WIC [1] and does support the formats you talked about. But you are correct that native .NET support for many image formats is non-existent.

And because they broke backward compatibility on so many libraries, it's a non trivial effort to convert a complex code base to core.

This is very true, and I felt it firsthand. My employer still has a codebase on .NET Framework (compiled against 4.5.2 but deployed against 4.8). It is WCF based and the jump to Core was a massive break. But in the end, I think the break was a good decision. There were just too many design mistakes, bad assumptions and underlying system changes to keep compat across the big leap to a modern multi-platform framework. .NET today is faster, more flexible and has more capabilities than .NET Framework ever did. Even if it did take a long time to get here.

And besides, even if new features are not coming to .NET Framework anymore, Microsoft has support .NET 3.5.1 until 2029! [2] Isn't 22 years of support enough? (.NET 4.8's EOL hasn't even been announced yet!)

[0] https://learn.microsoft.com/en-us/dotnet/api/system.runtime.... [1] https://learn.microsoft.com/en-us/windows/win32/wic/native-w... [2] https://learn.microsoft.com/en-us/lifecycle/products/microso...

Cache Benchmarks 1 year ago

If you look at Garnet's source code it is very non-idiomatic C#. It goes to extraordinary lengths to avoid the garbage collector. Almost all memory management is done with unmanaged memory and pointers.

They also have a very clever internal design and do some other tricks like strategically avoiding async/await and moving I/O operations onto the network request thread.

That doesn't make it ok or less impactful. He's been running MyNoise for years and it sounds like if he had been attacked before, this one was much worse, prompting a blog post about it.

You are correct but although the B52 can technically carry the GBU-57 MOP, but it was only done that way during the initial testing of the weapon. The B2 is the only aircraft the USAF actually uses for that munition in combat scenarios.

Also the B2 is better suited for extreme endurance missions like this where the plane is in flight for >36 hours. It has a toilet, microwave and a cot for the pilots to use during the more mundane parts of the mission.

The kinetics matter here. The B2 flies much higher than the C-130 which would aid the GBU-57 MOP (almost certainly used here) in it's ability to penetrate to maximum depth. 80% of the 15 ton weight of that bomb is just heavy metal to give it maximum energy as it borrows into the ground.

Also, each B2 can carry 2 MOPs making it a better platform than a C-130, and that isn't even taking the stealth of the platform into account

I would be happy to be wrong on this one. But I've gotten two pretty convincing threat notifications when visiting the page from the Sentinel One antivirus platform saying that my msedge process had been compromised by a known exploit.

I'll try to get more details.

I should note, I do not believe the site is malicious, but i am worried about 3rd party compromise of the site without the owner's knowledge

Did anyone else's antivirus complain about an exploit on this page?

---EDIT---

I'm about 98% sure this blog has a browser hijack embedded in it targeted at windows+MSEDGE browsers that attempted to launch a malicious powershell script to covertly screen record the target machine

It's more design and more thinking upfront, which is something the development community has moved away from in the past ~20 years with the rise of agile development and open source.

I agree, but even smaller than thinking in agile is just a tight iteration loop when i'm exploring a design. My ADHD makes upfront design a challenge for me and I am personally much more effective starting with a sketch of what needs to be done and then iterating on it until I get a good result.

The loop of prompt->study->prompt->study... is disruptive to my inner loop for several reasons, but a big one is that the machine doesn't "think" like i do. So the solutions it scaffolds commonly make me say "huh?" and i have to change my thought process to interpet them and then study them for mistakes. My intution and iteration is, for the time being, more effective than this machine assited loop for the really "interesting" code i have to write.

But i will say that AI has been a big time saver for more mundane tasks, especially when I can say "use this example and apply it to the rest of this code/abstraction".

Acutally it can be a lot more if you are talking about pause latency, I've seen >200x improvements on max pause time on some syntethic benchmarks