Those who use the bike know this very well: in the city, speeding motorists overtaking other cars, only get one thing: they arrive first to the next red.

With a simple model, the author estimated the probability that one car that overtakes another, will then be reached again at a later red light. Then he estimated the probability that the same thing will happen when there are multiple successive traffic lights, as usual in the cities.

The result is that as fast as an aggressive driver goes, the presence of multiple traffic lights makes it virtually certain that a slower driver will catch up

So, if someone aggressively overcomes you, when you reach him at the next traffic light, you can tell him that it is mathematically proven that he/she is an idiot.

In addition, this study has implications for the 30 km/h city, demonstrating how in urban areas the traffic lights determine the travel times, not the maximum speed reachable between one traffic light and the next.

The original scientific article is here: https://royalsocietypublishing.org/rsos/article/13/4/260310/481212/The-Voorhees-law-of-traffic-a-stochastic-model

crossposted from: https://poliversity.it/users/rivoluzioneurbanamobilita/statuses/116419204210303856

This must be one of the funniest event in the utility bike area

I re-watched the movie recently and noticed how may intro scenes are full of car traffic.

For example the Seine banks, full of cars in the movie, are now pedestrian only.

It would be nice to have a 1-to-1 comparisons, wouldn't it?

Source: https://yehudamoon.com/comic/2008-05-08/](https://yehudamoon.com/comic/2008-05-08/

crossposted from: https://poliversity.it/users/rivoluzioneurbanamobilita/statuses/116159715112186636

Nowadays there are several models that are able to consume the blades of angle grinders, increasing the fatigue and time that the thieves take to open them, so much so that it often becomes easier to cut the structure of the rack.

The Kryptonite looks unbeatable, but other models also reach good levels, too.

Finally, a reminder that a good lock is not enough, but you also have to lock the bike in the right way

cross-posted from: https://mastodon.uno/users/FIABSegrateCiclabile/statuses/116122085862164698

Interesting article from a generalist magazine. According to it:

• Best Preinstalled Phone: Fairphone 6 With /e/OS
• Best for Pixel Phones: GrapheneOS
• Best for Non-Pixel Phones: /e/OS
• For the DIY Tinkerer: LineageOS

Somehow this car was able to break through the railway fence, hit the rails and jump on the platform.

And car brains say bicycles are dangerous...

Article (in Italian): https://www.milanotoday.it/cronaca/auto-stazione-cesano-boscone-binari.html

cross-posted from: https://feddit.it/post/25146908

For context: a father teaching his 12 yo kid to drive. The kid pushed the gas pedal, couldn't stop, went through the railway fence, hit the rails and jumped on the platform. On Christmas day. Train traffic was interrupted for 4 hours

Article (in Italian): https://www.milanotoday.it/cronaca/auto-stazione-cesano-boscone-binari.html

This is the message of an old campaign for the #securityRoadway in #UK. It sounds ridiculous, if only the same message (maybe a bit watered down), was not used for road safety campaigns nowadays.

Pure victim blaming

crossposted from: https://poliversity.it/users/rivoluzioneurbanamobilita/statuses/115705207235775690

I find this mini reader very interesting, maybe a bit too barebone.

• 114 x 69 x 5.9mm (4.5″ x 2.7″ x 0.2″)
• 220 pixels per inch
• no front lighting
• 650 mAh battery
• ESP32 microprocessor: Wifi, bluetooth, usb-C port

TL;DR

I setup a local workflow that allows me to turn a webpage to an epub on my android phone and send it to my Kobo

Introduction

Since Mozilla killed Pocket, i have been looking for an alternative that didn't depend on decisions from any tech company, but only on myself.

I used the Pocket feature quite a lot, and, even if I appreciated the effort from Kobo to replace it with Instapaper, I didn't want to depend on someone else for something as simple as reading an article later on my eink device.

I considered Wallabag and Readeck, but, for both I had to depend on someone else server, or I had to self-host, and I didn't want to deal with the complexity.

I wanted an approach where I was in control, so all the steps needed to be based on FOSS software that I could at least understand.

The basic idea

I thought that what I needed is a 2 step approach, and I could solve both of them

1. Turn a webpage into an epub
2. Send the epub to my kobo

The explanation below is long, but, especuially following step 1-a and step 2-a is fairly easy and doesn't involve any modification or coding

Step 1: Turn a webpage into an epub

In the long search to do this I ended up finding 2 apporaches, on available "off the shelf" and one that involved much more coding.

Step 1-a: einkbro

i found out that there is a fantastic FOSS browser, EinkBro, that is designed for eink screen devices, but works very well for any Android device. It is slick, fast, configurable and well designed. It implements the readibility library from mozilla, which is great, and, more than anything else, can directly export webpages as epub files. You can configure the toolbar so that the "export to epub" icon is directly visible. The exported epub is nice, looks like the "readibility" version of the webpage (probably because it is...). So, when I want to save a article I share it from my browesr to einkbro, and, from there, I export it to epub.

Step 1-b: Termux + readiblity scrape + pandoc

For this one I went all-in the rabbit hole of total control... Or maybe I could have done worse. Anyway, here are the components:

• Termux: a terminal emulator for android, that allows you to do almost whatev you can do in a terminal emulator on a full blown Linux machine
• Readability scrape is a command line tool that scrpaes an url and returns a simplified version of it, using the readability library from Mozilla (as in the read-mode from Firefox)
• Pandoc is a command line tool that can convert documentation from one format to another, like, in our case, html to epub

I won't go into the details , of how to install what. In case, just ask.

I setup termux so that, if i share a webpage to termux via Andorid share menu, it triggers the following script ~/bin/termux-url-opener (see this webpage to understand how termux handles shared URLs):

termux-toast "termux received $1" # toast message to war that the url was received

termux-chroot "~/scripts/webpage_to_epub.sh" $1 

note: for some reasons pandoc works as intended only if executed in chroot, so that's why the follwing script is launched as from the command termux-chroot in the snippet above

webpage_to_epub.sh

#!/bin/bash

# final desitnation of epub file
FINAL_DIR="~/storage/shared/Documents/epub_articles/"

# Check if the URL argument is provided
if [ "$#" -ne 1 ]; then
  echo "Usage: $0 <URL>"
  exit 1
fi

URL="$1"
JSON_OUTPUT=$(readability-scrape --json "$URL")

# Check if the readability command was successful
if [ $? -ne 0 ]; then
  echo "Error: Failed to scrape URL."
  exit 1
else
  echo "readibility scrape: SUCCESS!!"	
fi

# Extract title and content using jq
TITLE=$(echo "$JSON_OUTPUT" | jq -r '.title')
CONTENT=$(echo "$JSON_OUTPUT" | jq -r '.content')
AUTHOR=$(echo "$JSON_OUTPUT" | jq -r '.byline')
CONTENT_LENGTH=$(echo "$JSON_OUTPUT" | jq -r '.length')  # Length in characters

# Calculate reading times based on character length
# Convert characters to words (approximate)
WORDS=$(($CONTENT_LENGTH / 5))

# Calculate reading times based on two speeds (200 and 300 words per minute)
READING_TIME_LOW=$(($WORDS / 300))  # For 300 wpm
READING_TIME_HIGH=$(($WORDS / 200))  # For 200 wpm

# Format the output for reading time
if [ "$READING_TIME_LOW" -eq "$READING_TIME_HIGH" ]; then
  READING_TIME="${READING_TIME_LOW} minutes"
else
  READING_TIME="${READING_TIME_LOW} - ${READING_TIME_HIGH} minutes"
fi

# Output the estimated reading time
echo "Estimated reading time: $READING_TIME"

# Format the current date in ISO format (YYYY-MM-DD)
CURRENT_DATE=$(date +"%Y-%m-%d")

# Remove accent characters and sanitize the title to create a valid filename
SANITIZED_TITLE=$(echo "$TITLE" | iconv -f UTF-8 -t ASCII//TRANSLIT | tr -cd '[:alnum:]_ ')  # Convert to ASCII and keep alphanumeric characters
SANITIZED_TITLE="${SANITIZED_TITLE// /_}"  # Replace spaces with underscores

# Create the final filename with date prefix
EPUB_FILE="${CURRENT_DATE}_${SANITIZED_TITLE}.epub"

# Create a temporary HTML file
HTML_FILE=$(mktemp /tmp/readability_output.XXXXXX.html)

# Write the complete HTML output
cat <<EOT > "$HTML_FILE"
<html>
<head>
  <title>$TITLE</title>
</head>
<body>
  <h1>$TITLE</h1>
    <div>
    $READING_TIME | <a href="$URL">original link</a>
  </div>
  <hr />
  $CONTENT
</body>
</html>
EOT

# Create a temporary title file for metadata
TITLE_FILE=$(mktemp /tmp/title.XXXXXXXXX.txt)

# Write the Pandoc YAML metadata block
cat <<EOT > "$TITLE_FILE"
***
title: "$TITLE"
author: "$AUTHOR"
EOT

# Convert the HTML file to EPUB including the metadata
#pandoc "$TITLE_FILE" "$HTML_FILE" -o "$EPUB_FILE"
pandoc "$HTML_FILE" -o "$EPUB_FILE"

# Check if pandoc command was successful
if [ $? -eq 0 ]; then
  echo "EPUB generated: $EPUB_FILE"
  mv "$EPUB_FILE" ~/storage/shared/Documents/epub_articles
else
  echo "Error: Failed to generate EPUB."
fi

# Clean up temporary file
rm "$HTML_FILE"

read -p "Press [Enter] key to continue..."

I spent time to craft the script to produce an output that I like, but, honestly, it's not better than the one produced by einkbro in Step1-a. The advantage with the termux script is that it is a one click process. I share the link to termux, and the script generates the epub and saves to a folder that is setup in the next step to do the uplaod automatically

Step 2: send the epub to my kobo

Again also for step 2 i found 2 alternatives, one more "manual" and direct, and the second more automatic

Step 2-a: share to http

For this I use a simple app, share via http: I share the epub file via android share menu to this app. The app generates a mini web server at my local IP address (on the wifi, that can also be the one from android hotspot). I then use the kobo browser to the local address. The browser asks if you want to download the file. Once downloaded the file is added to the kobo ebooks.

By using Nickelmenu I added a shortcut to the kobomenu to start the browser, to make things faster.

This is the simplest solution, everything work locally, no third party involved

Step 2-b

As an alternative I setup a nextcloud sync.

• On android I setup the folder where I save epubs as "automatic upload", so epub files are uploaded to a folder on my nextcloud as soon as I asve them
• On kobo I setup nexcloud syncronization. There is more than one alternative, I used this one. Whenever I connect my kobo to wifi, the new epubs are downloaded to my kobo and added to the library. The only downside is that to delete an article, I have to delete form the nexcloud foder; if I delete it from my kobo, it gets re-added as soon as I connect the wifi

Conclusions

Maybe this looks too complex, but I learned a lot of stuff and had fun in the process. i find that pandoc is probably a bit too much for what it is needed here, in the end the epub content is a bundle of html and images, probably there is a better and slicker way to package them. If you have any suggestion to improve the workflow it is welcome :-)

What do you use these days?

Munich has some issues dealing with too many cars and illegal parking on the sidewalk is common.

The SPD mayor has the solution: change the law so that this rude habit becomes legal.

And what about pedestrians, people with wheelchair, strollers? I guess they'll have to adapt.

Fuck cars!