Marcin Szamotulski, PhD
Curriculum Vitae

Curriculum Vitae

Intro

I am an experienced developer, and I have proven myself across a variety of challenges involving designs, implementations, and minimum viable products.

code quality

I am as curious, open, and quickly learn as I am collaborative. I combine all this with an abstract thinking skill worthy of my academic background, which is PhD in maths. I put effort into making the code comprehensible, which is important for both collaboration and maintnence.

maintenance, testability and deadlines

When designing code, I think forward and craft solutions in a way that others can pick up easily. Simplicity is not easy to achieve, especially in large and complex systems, but it's a good aspirational goal.

Testing code early is paramount. On tight deadlines, there's often not enough time to write thorough tests. If that's the case, recognising which tests are essential and which can be postponed is a useful skill. In the long run, wise code reviews always pay back.

By using modern property testing techniques and simulations, I was able to deliver complex network components which worked flawlessly on various platforms, from loved by developers Linux and macOS machines to Windows.

functional programming

I am an advocate of functional programming. It often brings clarity, projects become easier to comprehend, and allow for a reasonable way of managing side effects.

I am an active member of the Haskell ecosystem. I am contributor of various key libraries including base, containers, haddock and cabal. I speak at engineering conferences and workshops or encourage my team mates to do so. A few of my recent talks:

Education

PhD: Research in Abstract Algebra and Category Theory, Instituto Superior Técnico, Lisbon.
Master in Mathematics: College of Inter-Faculty Individual Studies in Mathematics and Natural Sciences of Warsaw University, where I was studying Mathematics, Physics and Psychology.

Career Chronology

2009-: Python and C programmer (open source)
2009-2013: PhD in Mathematics, IST, Lisbon.
2013-2015: freelancing
2015-2017: Rubble, LTD, London.
2017: Gravicus (now Smartbox.ai)
2017-: IOG, network team lead for the Cardano project.

Portfolio

Some of the most recent projects I worked for or training I took part of:

IOG

Currently I work at IOG as the team lead of the Cardano Networking Team. I also held a teaching assistance position for IOG / Well-Typed's Haskell course, which took place in Barbados in 2018.

Majority of my work at IOG is available as open source. I mostly work on ouroboros-network repository. I contributed both to the design as well as implementation, which is documented in a technical report.

Here are my main achievements:

  • I contributed to the session-type framework typed-protocols. Using type level description of a protocol not only turned protocol errors into type errors but also made it much easier to share and discuss ideas: using typed-protocols protocol state machines became the primary focus point. It allowed us to reason about protocol behaviour, especially about adversarial behaviour. The novelty of typed-protocols is using protocol pipelining in the context of session types.
  • I authored Win32-network library.

    One of IOG's products, the Daedalus wallet is a primary Windows application with thousands of users. This library, together with a small abstraction layer, allowed us to write platform-independent code (which runs primarily on Linux, Windows and macOS). With Win32-network we ware able to achieve a similar throughput to one observed on Linux and we never heard back complaints from Windows users regarding networking!

  • I am one of the primary contributors to io-sim: an IO simulator and a drop in replacement for IO monad. IOSim is a pure monad (free monad) which supports:
    • Haskell thread interface
    • Haskell synchronous and asynchronous exceptions
    • async interface
    • stm (software transaction memory) interface
    • time primitives, which are important for writing network simulations
    • it has been extended by Prof. John Hughes to explore different thread schedules (using an approach similar to one described in Optimal Partial Order Reduction. See slides of my recent talk on partial order reduction in IOSim.
    • and more ...
    It allows to write production components that can run both in real IO and in simulation. Testing components in simulation using property testing proved to be a thorough and efficient way of checking correctness. We combined simulation testing together with contravariant tracing, which gave us insight into how the internal state evolves during the simulation and verify that it behaves as specified. We applied this approach to multiple complex components.
  • I wrote a network simulator based on the io-sim library, which allowed us to test cardano-node diffusion layer. The simulator allows to:
    • simulate communication between multiple components in a distributed system
    • do error injection and simulation of network attenuation
    • simulate a TCP simultaneous open, which as observed by us, is not a rare event on Cardano mainnet
  • I wrote and maintained several protocols using typed-protocols package.
  • I have been one of the main contributors to the Stake-Driven Peer Selection with Robust Peer Discovery, also known as peer-2-peer of the ouroboros-network. This layer automates the creation of the overlay network. It was designed specifically to be able to
    • connect across NATs
    • utilise full-duplex connections to save the number of file descriptors used by the diffusion layer and punch holes in NATs
    • be able to respond and adapt to changing network conditions
    • be robust, in particular, protect against resource exhausting attacks
  • I also helped to maintain CI using github-actions, and nix.

Haskell network programming nix

Well-Typed Guide to Haskell Performance and Optimization

In October 2018, I took a two-day course organised by Well-Type at Skills-Matter in London titled Well-Typed Guide to Haskell Performance and Optimization.

The training covered low-level data representation used by Haskell runtime system, lazy evaluation, Haskell intermediate representation, insides into Haskell optimisations strategies (strictness analysis, inlining). With examples based on real bugs found by Well-Typed engineers while doing Haskell consulting around the world.

Haskell

Functional Correctness Training

In November 2018, I took part in a Functional Correctness Training delivered by Prof. John Hughes (one of Haskell founders and the original author of QuickCheck library), Well-Typed and IOG.

The training covered advanced usage of QuickCheck and property-based testing, semi-formal specifications.

Haskell QuickCheck

Gravicus

I worked at Gravicus, where we used PureScript and React. I set up various projects using Redox.

I was also responsible for implementing pixel-perfect designs, closely working with our designer. Writing complex UI elements using pseudo-elements and well-designed modern css.

Progressive Web App PureScript React Redox HTML5/CSS3 CssModules WebPack karma purescript-enzyme purescript-unit-test

Zephyr

This is an open-source project which provides a tree shaking algorithm for PureScript. It outputs a set of CommonJS modules which can be bundled with webpack, rollup or any other tool. zephyr allows to build lazy loaded applications that are also properly minified before shipping. This opens new possibilities in the PureScript ecosystem.

Haskell PureScript

Rubble

I have delivered progressive web apps written with ReactJS and Knockout and relied on custom Rubble logic language for the backend, as well as Python and NodeJS.

My job as a JavaScript, Python and Rubble engineer was to develop applications based on rubble logic programming platform, documentation proofreading in close cooperation with our CTO.

Flask (Python) Flask-Restful (Python) nodejs Rubble websockets Progressive Web Apps ES6 React Redux Knockout jQuery Crossroads Hasher HTML5/CSS3 LESS SASS Twitter Bootstrap gulp Browserify WebPack

Scientific Publications

Some papers and preprints that I authored or co-authored: