Pascal's Scribbles

This post introduces Readleif, a read-later and listen-later app for iOS and macOS that I built this summer.

If you’ve ever needed to produce a typed binary format where the header constrains what the body can contain, you’ve probably written validation code that runs at runtime and hoped your tests cover the edge cases.

While working on seqair (see my post here ), I also wrote a bunch of wrapper types for the domain we work in.

This post introduces seqair , a new Rust library for bioinformatics formats I’ve been working on.

I published three posts on this blog just in April.

In my recent post on Rastair , we looked at some performance best-practices and optimizations for Rastair , a bioinformatics tool that I’m currently working on.

Styling SVG symbols that are defined using <symbol id="x"> and included using <use href="#x">.

In the last year, I’ve had the pleasure to work on Rastair , a bioinformatics project by Benjamin Schuster-Böckler from the Ludwig Institute for Cancer Research at the University of Oxford.

Recently, I’ve been working on a Rust project again.

Bevy is a game engine written in Rust that is known for featuring a very ergonomic entity-component-system.

Out of curiosity I’ve recently started following the development of Bevy , a game engine written in Rust .

It seems especially recently I’ve come across more and more long-form texts (think: hour-long blog posts; free books; series of posts).

So you’re writing Rust but it’s not fast enough?

One surprising feature of type inference in languages like Rust is defining functions with generic return types.

Despite my best efforts, I end up logging into Linux servers and checking how they’re doing way too often.

Note: This post is about how I arrange the code I write in Rust.

The Rust project is asking for blog posts about what the community would like to see happen with Rust in 2019.

Say you want to store a huge number of very small files that you will only access over HTTP.

A lot of people at RustFest Paris mentioned Cows – which may be surprising if you’ve never seen std::borrow::Cow !

I recently wrote a new Rust crate: quicli .

Instead of fireflowers , this year the Rust Team made a public call for blogposts , asking the community to write posts that reflect on Rust in 2017 and what they wish for Rust in 2018.

As someone who likes writing code in a functional style, I really enjoy passing functions as arguments.

I’ll be at various conferences throughout the year 2018.

There are many different ways to learn something; one that I enjoy from time to time is what I’d call the “jump in at the deep end”: Look at the solution to a problem and study each of its details until you understand all the concepts.

Rust is a great language to write small command line tools in.

Diesel is a type-safe query builder for Rust.

I’ll be at various conferences throughout the year 2017.

Rust has a pretty powerful type system, but some things are not that easy to express.

A short overview.

Rust’s error messages are pretty amazing.

Here are some things in Rust’s ecosystem that I really like: The awesome people Well documented libraries by awesome people Automation to help awesome people focus on awesome stuff I would like to add something to that.

[The] length of a variable name should be proportional to its scope.

How do you teach people how to use a complex framework or library1?

I hear a lot of people new to Rust are Ruby programmers.

Update: Got the laptop, and some adapters.

Some time ago I forked biggie , a small tool to generate a slideshow from markdown.

Actually, the title is a lie: We are just focusing on traits here, but writing Rust can also easily be Test Driven, or Data Driven, or Documentation Driven, or [A-Z][a-z]* Driven.

One of the most amazing features of compilers is their ability to not just transform code into machine-readable things but also to optimize away abstractions.

Some ideas for editor/IDE features to make working on Rust code more pleasant.

I really enjoy working with plain text files.

I have a directory full of research papers I have read or want to read.

Like most other (\w)DD techniques1, “README-driven Development” wants to guide your approach to software development.

In Rust RFC 1713 , a set of documentation ’tags’ is proposed, to document functions in a similar fashion to e.g.

Recently, I wrote on reddit that a Rust book won’t become obsolete in the next years if it focused on explaining concepts instead of current APIs.

Have you ever seen the way Github allows you to see rendered diffs for code they can render as HTML?

When I first wrote about Silicon Zucchini (the code name for my statically-typed CMS, see also this note ), I mentioned that the JSON schema files that are used to validate the content data could also be used to generate an editor interface.

The secret life of std You can call "text".parse::<T>() on all types T that impl std::str::FromStr for T You can .collect() into a Result<T, E> where T: FromIterator Formatting syntax (as in format!

I want a static site generator that enforces a bunch of rules at compile-time so whole classes of errors cannot occur.

Among other things , I want to easily write UIs in Rust.

The existence of libraries with nice, user-friendly interfaces is one of the most important factors when choosing a programming language.