Ever been admonished by a much-higher-up at your company for something you tweeted?
I once tweeted a joke about how Microsoft ❤️ reorgs and got a "not cool" email from someone whose boss reports to Satya
He thought I was leaking info on an upcoming reorg I knew nothing about
Here's something
@BehluliLedjon
& I have been working on: locality-aware repartitioning for
@msftorleans
! It shuffles grains between nodes in the cluster to reduce cross-network calls, resulting in 30% to 110% throughput improvements in early benchmarks.
For .NET devs,
@msftorleans
gives you this.
Efficient in-proc calls when you're in-proc, fast RPC when you're not. Orleans is battle tested, modern, and used in-production for some of Microsoft's largest svcs. It goes further, supporting versioning, rolling upgrade, & much more
Towards Modern Development of Cloud Applications
"microservices conflate logical boundaries (how code is written) with physical boundaries (how code is deployed)."
"we propose a different programming methodology"
"Our implementation reduces application latency by up to 15x and
High volume console logging on .NET can take down your app. The Console logger uses a dedicated thread to pump logs from a queue to the console. That queue has a max length of 1024 items. When that limit is hit, all threads which are logging will block and GG your app
If you're curious how Orleans decides which hosts monitor which others, it's rather simple:
Servers are arranged into a ring based on the hash of their identity, and each server monitors its N successors around the ring.
Nice dev tooling won't push the envelope for cloud app development when the core problem is programming models that leave developers unequipped to manage concurrency, state, fault tolerance, and scalability. There's more to Developer Experience than tooling.
If you're writing
#dotnet
Source Generators and want to use Roslyn APIs to build the syntax,
@linqpad
can save you heaps of time. It will even generate the syntax calls for you (see the button at the bottom)
A fast (😉), standalone Write-Ahead Log implementation in .NET! This can be used for building many kinds of databases and distributed systems without relying on the rest of the FASTER Key-Value store
I pushed my durable workflows PoC branch:
C#'s async/await is very extensible, allowing me to introduce a new type, DurableTask<T> which allows most of the code to be quite clean. Orleans' RPC understands how to handle methods returning DurableTask<T>, too
The Amazon Prime Video team was able to reduce cost by moving from Serverless backed by Lambda to monoliths running on VMs.
"Moving our service to a monolith reduced our infrastructure cost by over 90%. It also increased our scaling capabilities."
Dist Sys Twitter: I'm looking for papers & posts about databases built atop cloud blob storage (or any disaggregated storage system). I know of Foundation DB &
@warpstream_labs
(Kafka API backed by blob storage). Any others? Suggestions are appreciated!
Microsoft's internal IT department likes to make terminal windows flash on your desktop occasionally, just to normalize the idea of unknown scripts running on your desktop
This talk is focused on how the RPC & Serializer in Orleans work and how they are designed for high performance. Rather than being Orleans 101, it's a perf-focused look under the hood. Some examples 👇
To be clear, I knew nothing but was just very enthusiastic and interested. I deleted the tweet as soon as I was notified.
Still, a lesson learned, I suppose: leave the open speculation up to people who don't work for the company
Quick demo of Aspire, which lets you use C# to describe an app's services + deps & how they relate so it can wire up observability, debugging, integration testing, service discovery, config, secrets, provisioning, deployment and a dashboard. The core idea is simple and powerful
When I was a contractor working remote from Australia, I tweeted my excitement/speculation about something called "Cosmos DB" that I discovered by scouring publicly available Build session info and got told off. Thankfully this hasn't limited my career (yet 😉)
@RogerAlsing
@J_Motoki
Some people don't appreciate just how fragile life is.
Reminds me of a guy from my hometown who thought it would be a good idea to drive up the middle of Australia solo, unprepared, without telling anyone. He died.
Build cloud apps in C# with
#NoYAML
. Launch your multi-project, multi-container apps with one command. Run integration tests locally without hassle. Plus, cloud provisioning, deployment, & observability (locally via the dashboard, in the cloud with
#OpenTelemetry
)
This is what I’ve been spending time on for the last couple of months. I’m so proud of the team for working hard on this first preview release. Still lots of work to do, but it’s pretty darn cool 😎
#dotnet
#CloudNative
Azure Storage uses Reed Solomon codes on cold data to reduce storage costs while maintaining resiliency. Once a segment has been sealed, it's a candidate for erasure coding. Hot data is stored without erasure coding, replicated to at least 3 locations
.
@Cloudflare
Durable Objects goes virtual actors:
The previous reentrant model is now replaced with an actor-like behavior where each function runs to completion before executing the next.
Also, storage is now cached in mem.
I have to give this a try :)
I initially thought System.CommandLine might be yet another args parsing lib.
Then I saw a demo of it.
It's surprisingly cool.
You get a strongly-typed Main(..) with tab completion and a lot of other goodness with very little effort
My mum was a programmer. Typical kid me wanted to make video games. I opened up an exe in Notepad and asked her to read it. I had no idea. She gave me her old BASIC book & I eventually got a copy of QBASIC on 💾 & have been happily coding since. Thanks Mum ♥️ (pic Dec 15 1984)
@IndiciaObscure
@RogerAlsing
@J_Motoki
Australia has only 24.6m people and is the size of the contiguous USA. The outback is especially sparsely populated. He apparently strayed from the road to find sticks to un-bog his car and was bitten by a snake, according to a note he left
Satya Nadella re: the metaverse:
"Across the Microsoft Cloud – from Azure IoT to Azure Digital Twins, to Connected Spaces, and Microsoft Mesh – we are building the metaverse platform for you to build upon."
Woo! Orleans networking replatted onto Bedrock bits!
#merged
! Currently using fork of bedrock bits but we will delete in favor of shared code when they GA
A system was failing consistently during load tests. Looking at a memory dump, ~1000 threads were waiting on a simple, short lock - a lock convoy.
Removing a call which was setting the ThreadPool's min threads to 1000 alleviated the issue & let them scale to much higher RPS
You can avoid 2PC by migrating the objects involved in a transaction to a single server for the duration of the transaction. If the graph partitions well, this should enable great perf. There are surely papers exploring this idea, do any come to mind?
If we draw database rows as points, and add edges between rows that appear in the same transaction, the resulting graph is a great way to think about potential scalability. The more you can cut the graph up without crossing edges, the easier the workload is to scale.
📢 "The One Billion Row Challenge"
How fast can YOU aggregate 1B rows using modern
#Java
? Grab your threads, flex your SIMD, and kick off 2024 true coder style by joining this friendly little competition. Submissions accepted until Jan 31.
👉
Constantly shooting down ideas is one way people suck the air out of a room.
Being overly exuberant and immediately taking charge is another.
Neither of those gives others space to grow and lead
Hagar is coming along nicely. Started optimizing the deserialization path last night. I have a few more tricks with intrinsics to implement and some other things. It's v. fast while also being version tolerant, and supporting polymorphism and cyclic graphs is👌
Most application developers likely dont understand ACID transactions well, but I wonder how many believe transactions are important for preventing bugs anyway. What do you think?
Orleans 2.3.0 makes it easier to co-host with by adding support for the new HostBuilder ( Core 3.0) and allowing you to inject IGrainFactory into your controllers
v2.3.0 is out with hosting APIs aligned with Core, EventHub dependency update, automatic cleanup of cluster membership table, hosted client enabled by default, Linux CPU/memory statistics, and other improvements and fixes.
Snapper - a new transaction processing system built on
@msftorleans
! 🎉
Paper: Hybrid Deterministic and Nondeterministic Execution of Transactions in Actor Systems from
@sigmod
2022
@bonivivek
@ylzhou
@nickchapsas
.NET 6 EoL is only 6 months after .NET 7 EoL
The way people treat them, you'd think there was a difference of years.
I wonder if mgmt policies would change if we increased STS lifetime by 6 months so that there was no downside to picking an STS over the previous LTS
C# 8 lets us write something similar to
#golang
's 'defer' statement. Maybe C# 9 can make this cleaner with `using new Defer(...)` or even `using Defer(....)` and more performant by removing `IDisposable` requirement for non-ref structs
@colmmacc
They tested benchmarks, i.e. short-lived programs which aren't representative of cloud workloads. Many of those programming environments include compilation, profiling, & optimization during their warmup period, which is expensive, but that cost is amortized over time
As a kid I once wrote to a computer magazine to ask if they could include the JDK on their cover disc because it was too big for me to download over dialup. They did 😊
Code must be mutable because real-world applications evolve over time. If your app framework makes it difficult to modify code, that's a big problem... but developers won't see that in your demos. The same goes for concurrency, scalability, and fault tolerance.
Tech interviews focus so much time on writing code instead of debugging code. Debugging ability is one of the core skills I look for in more senior engineers.
I'd like to see us unify the two: workflows and virtual actors. I have some ideas for what I consider a good programming model to accomplish that and hopefully improve upon what I consider shortcomings in the existing programming models for workflows
The developer experience is worse today than it was just several years ago. The Cloud Native Landscape is incredibly complex. We built tools to patch over fringe problems & tools to manage the complexity those other tools introduced. It's a big, distributed ball of mud.
Old keyboard (above) vs new (below). Ideally, I'd use plain key caps with no legends, but those are hard to find, so I settled for this colourful set with weird symbols
Instead of losing state when a peer crashes, surviving peers are consulted to rebuild the lost partition. Since they necessarily have the information, loss is avoided. Consistency is maintained by pausing queries for recovering ranges until recovery completes.
I'm applying Virtual Synchrony / Vertical Paxos ideas to a new grain directory implementation for Orleans. It's dynamically range partitioned, which brings challenges, but in 700 LOC it gracefully scales out & in without data loss or consistency violations.
I hope this performance focus in .NET leads to more data systems, like storage engines, databases, stream processing systems, full-text search engines, etc.
Writing docs for
@msftorleans
this week. This article is about implementation details of the task scheduler. Let me know if this is clear or if there's something which could be clarified/improved: