All posts by admin

Selfhosting in Era of Cloud

Today one can choose from overwhelming variety of online (cloud) services in almost any thinkable area. Many of them provide vast amount of content and have professional user interfaces / clients. So why to bother with selfhosting, when one can just choose from this broad offer? And I’m here referring mainly to personal selfhosting – e.g. running some services from computer/server running at your home and providing these services to yourself plus family members. Does it make still any sense, when you can hardly compete with internet giants? In this article I’d like to present few reasons, why I think that selfhosting still have some values.

Continue reading Selfhosting in Era of Cloud

First Impressions about New Rust Async

Just recently async and await made it to stable version of Rust. futures library 0.3 is also out and rest of other important libraries is following – for me tokio and hyper are particularly interesting. tokio is now in alpha stage supporting new futures, so I decided it’s about a time to give it a try. Some time ago I’ve rewritten ptunnel in Rust using 0.1 version of tokio and futures. So here are my first experiences with new libraries and upgrade.

Continue reading First Impressions about New Rust Async

Audioserve new features

I have been working on some new features in audioserve and they are now available in latest releases. In this article I’d like to talk little bit about them and probably later also provide new demo videos, as there has been many changes from last demos.

Summary of new features:

  • Single file audiobooks (m4b) support
  • Alternative subfolders sorting (recent, alphabetical) and most recent folders list
  • Folders download in web client
  • Easier deployment with smaller docker image or static binary
  • Server config file
  • Playback sharing/synchronization between clients

See below for details.

Continue reading Audioserve new features

Higher Rank Trait Bounds in Practice

Higher Rank Trait Bounds (HRTB) is relatively advanced feature in Rust, you can read short explanation in the reference, and more detailed explanation in in the RFC (frankly spoken RFC is bit more complicated, at least for me).

HRTBs are applied for lifetime parameters only (at least now) and are useful in cases where lifetime parameter in trait cannot be bound to any existing lifetime, but is valid for any particular lifetime, that happen to appear in place where type implementing the trait is used.

Continue reading Higher Rank Trait Bounds in Practice

Lightweight Tasks Switch in Go vs Rust

I’ve have been following this excellent book “Operating Systems: Three Easy Pieces” and as I’ve been doing a homework – measuring time of context switch and as I was looking around and found another interesting article related to this topic. It also compares thread switches to switches in “Go routines” – lightweight threads in Go language. Base on these sources I’m made couple of mine own test (yes I know, all benchmarks sucks, but nevertheless they are somehow attractive (as gossips are) and somehow addictive).

Continue reading Lightweight Tasks Switch in Go vs Rust

Rust, I love you, I really do

In past 5 years Stackoverflow was running a comprehensive survey (here is latest for 2019), which, among other questions, asked for ‘most loved programming language’   – which basically means language developers used, like it and definitely want to continue with. Rust is doing very well in this category – it leads this category for past 4 years ( and this was one of reasons, why I started to play with Rust).  As this SO survey (with similar questions) is around for 5 years, it’s about time to put data in chart: Continue reading Rust, I love you, I really do

Hyper Websocket

As much as I do like Rust I have to admit there are some disadvantages of using this language – one common problem is immaturity and fragmentation of libraries –  I encountered this recently when I was looking for a way how create a websocket endpoint for audioserve.  audioserve is using low level HTTP library hyper – as it’s API is quite simple (which was it’s key design principle). I wanted to add websocket support on lowest possible level.  Actually it turned out as not totally trivial –  some frameworks like warp or actix have build in websocket support, but for pure hyper + websocket we have to start from bottom.  Continue reading Hyper Websocket

Static Build of Rust Executables

Recently I wanted to create completely static build of audioserve – so it can be easily moved and  run on any modern 64bit linux without any other actions. Rust provides some guidelines for static building, but it still took me some time to make it work, mainly due to dependencies on other C/C++ libraries (libssl, libavformat …). So here I my experiences: Continue reading Static Build of Rust Executables

Future Is A State Machine

I think I noticed in this article that Rust Future is basically a state machine, which is propagated through its states via appropriate runtime (and parked when not ready to move to a next state). But I did not appreciate this fact fully until recently I was making a small utility for creating tar archive asynchronously – it should be a Stream that produces chunks of data – first file header and then pieces of it’s content. When file is done move to next file, until all required files are sent to stream, then finally send two empty blocks, each of 512 bytes of binary zeros. I needed this Stream for my audioserve project, where I wanted to download content of whole directory as a tar archive. Stream is a kind of Future (which produces many values instead of just one), so it’s also a state machine. And when I started to think about it this way, implementation was obvious. Rust algebraic type system is of great help here as we can represent state  with one complex enum type ( called TarState in this case) and it’s variants represent states of this state machine and also contain necessary internal variables for each state.  So lets see state diagram for our TarStream: Continue reading Future Is A State Machine

Split Large Audiobooks – A Better Way

In previous article I presented bash script to split large audiobook file into smaller parts. It worked well for me, but has one limitation – if chapters information was not available in the metadata, then file was split into parts of exact size, which was clearly sub-optimal, as split can fall into middle of a word.  So I created new script (this time in Python as logic was bit more complicated, more then I’m conformant to implement in bash), which first detects silent spots in the audiobook and splits file there. Additionally you can also supply external CSV file, which defines  mapping  to chapters (It’s easy to create this file, just require a bit of patience and good tool like audacity to capture the exact positions of chapter ends). I tested my tool on tens of large single file audiobooks and it seems to work fine. You can check this script in its github repo.