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-:
IOG, network team lead for the Cardano project.
Portfolio
Some of the most recent projects I worked for or training I took part
of:
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
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
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
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
I used to be an active member of the PuresScript
community, I contributed to the PureScript
compiler, and I authored and maintained various libraries.
I also made non-trivial contributions to more than a few core libraries,
to mention a few:
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