My name is Bartosz Sypytkowski. I'm one of the core team members behind Yjs/Yrs ecosystem. If you need help with them (or have any other problems in Conflict-free Replicated Data Types domain), I'm available as a contractor. Feel free to DM me at Twitter or via email.

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. Latter one has also been extended via Plumtree protocol description.
• 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.
• How to build async-aware Read/Write lock operating in user space over .NET green thread model (Tasks).
• How to build Range tries: data structures used for efficient indexing of multi-dimensional data.
• Details on how live backups and point-in-time recovery are performed by databases.

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).

Some of the open source projects I contributed to:

• Yrs - it's a Rust implementation of Yjs library (one of the most performant CRDT libraries for building rich collaborative documents), targetting multi-platform systems and serving as foundation for multiple language bindings including Web Assembly, C FFI, Python or Ruby.
• 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.