My name is Bartosz Sypytkowski. I'm a passionate about data management, distributed & concurrent systems, their internals, protocols and algorithms driving them. You can see some of the recent topics of my interest on my blog post. Some of my personal favourites:
- Series of posts introducting to Conflict-free Replicated Data Types.
- Walkthrough (with implementation) over SWIM and HyParView cluster membership protocols.
- Post about tradeoffs and building custom user-space threads in F#.
- How to build custom thread-per-core thread pool.
- How to build custom actor library.
- A bunch of tips related to CPU/memory optimization of .NET programs from F# developer point of view.
While I look at the platform/runtime as a tool to achieve the goal, my personal weapons of choice include: Rust (which I had pleasure to work with when implementing JSON-like CRDT document database at ditto.live), Scala, F#, Go.
From time to time I manage to speak at user groups and conferences. Your can see some of my presentations on youtube and slideshare. Feel free to contact me (you can see e-email in my github profile).
Hall of fame
Some of the open source projects I contributed to:
- Akka.NET - for over 5 years I was member of core-team, where I helped building a various parts of this distributed actor framework, including:
- Akka.Streams, which is a reactive streaming library build on top of akka actors, that allows programmers to build a rich dataflow graphs with backpressure support. This also included building a direct API for safe and composable socker server and client as well as StreamRefs - surrogate objects used to transport and join Akka.Streams graph nodes over the network, allowing users to build a distributed, backpressured dataflows.
- Akka.Persistence which is a plugin, that introduces support to actor state persistence by using eventsourcing techniques. Later on I also introduced Akka.Streams support to it as well as SQL database adapters.
- Akka.DistributedData which introduced a decentralized, replicated in-memory key-value store build into akka cluster, based on Conflict-free Replicated Data Types. Later on it was extended to use optimized delta-state CRDTs and durable storage.
- Akka.Cluster.Sharding which enabled automatic shard-based actor placement, with rebalancing strategy that enabled efficient cluster resource utilization.
- Cluster split brain resolution strategy, which was reverse engineered from canonical Akka JVM documentation (it was not open-sourced back then).
- Akka.Persistence.Reminders which extended eventsourced capabilities of Akka.Persistence to support long-running timers. It also included support to cron expressions.
- Akka.Cluster.Discovery which is a node-discovery service, that enables to use 3rd party systems (like Hashicorp Consul) to mediate in akka cluster initialization.
- F# pluggin for Akka
- Support for mutli-datacenter aware clusters
- Second shot to eventsourcing with support to replicated partially ordered event log - based on eventuate Akka library.
- FSharp.Data.GraphQL which is Bazinga Inc. sponsored project, where I implemented a server-side part of GraphQL standard specification. Memorable challenge was to implement GraphQL-to-LINQ converter, that was using not only GraphQL query AST, but actually tracked usage of data members in underlying F# code used in field resolvers.
- Hyperion which is a very efficient binary serializer, aiming to provide a wide features support eg. serialization of object graphs with cycles, serialization of expressions and delegates, version tolerance.
- A growing collection of various Conflict-free Replicated Data Types, including state-, delta-state and operation-based ones (with example replication protocol support).
- A F# utility library, with various extensions like high performance persistent vectors, hybrid-logical clocks, reentrant user-space read/write locks, set of operators over IAsyncEnumerable interaface or high performance actor implementation.