Software's new consolidator gets big vote of confidence from Berkshire

Furnished content.

Less than four months into life as a public company, Bending Spoons got a big vote of confidence this week from Berkshire Hathaway.

Read more here

The $27 tool that should touch every outlet before your screwdriver does

Furnished content.

Use this electrical safety device first before you touch any wiring in your home DIY project.

Read more here

I changed what happens when I tap a link on Android and there's no reason to do it the old way anymore

Furnished content.

Now I look inside a link before it opens.

Read more here

Only one major phone maker won't let you turn off battery throttling

Furnished content.

Battery health, forced.

Read more here

AI stocks plunge. Inflation heats up. Where we're still finding opportunities

Furnished content.

The sinking AI trade rattled last week's market. But solid bank earnings and a rotation beyond tech gave us reasons for optimism.

Read more here

Adventures in Real-Time MIDI

Furnished content.

Preamble

Since discovering Perl real-time MIDI and writing about creating async drums with it, I’ve dug deeper into what’s possible. I have a few music and MIDI modules on CPAN and like to put them to use in real time, now that I have been enlightened by zen master John Barrett. Ha :DThis will be a mostly commented-code illustration of real-time arpeggiation. It is maybe “just a hobby.” But the principles of asynchronous programming, periodic execution of a set of things, are generically applicable to other types of problems.There is no perplexing music theory here: just some terms to know. A note is a little vector of a pitch (high or low) and a duration (long or short). A scale is a collection of pitches, starting at the tonic. An octave is the musical interval between one note and another, where each has the same letter name but twice (or half) its frequency (in Hertz). A clock is a MIDI message sent to a device to keep timing. MIDI stands for “musical instrument digital interface” and is the beating heart of a lot of digital music. An arpeggio is usually a chord of the chosen scale, where the notes are played individually in rising or descending order. A chord is a collection of three or more notes. An arpeggio is played over a given spread or range of beat durations. A beat is an atom of the rhythm. The rhythm is the collection of note durations of a phrase. A measure of musical time is a group of beats most commonly four. Finally, the term velocity is equivalent to the volume or loudness of a note. Whew!Anyway, on with the show. (And audio examples are at the bottom.)

Broad strokes

What this is:A generative arpeggiator that runs forever, choosing random scale notes and random arpeggios. This plays them on a MIDI synth, all driven by a MIDI clock.The core ideas:

A universe of notes defined by a tonic pitch, a scale name, and a set of octaves
An asynchronous clock engine using a periodic timer to drive events and MIDI messaging
Phrase generation with flexible arpeggio parameters and velocity randomization
Graceful shutdown with all-notes-off/panic being the important part

Code overview:

Dependency imports
Optional parameters that guide the processing
Internal parameters defining program operation
Cleanup on program halt
Loop and periodic timer
Handy subroutines

Basically, this code is all machinery to play things in real time. The actual arpeggiation is pretty simple and happens at the beginning of the trigger_notes() routine, given the object.Let’s look at each of these in closer detail.

Dependency imports

use v5.36;                                          # use a modern Perluse IO::Async::Loop ();                             # asyncuse IO::Async::Timer::Periodic ();                  # asyncuse List::Util qw(max sum0);                        # duration scalinguse MIDI::RtMidi::Util qw(out_port stop_all_notes); # rt-midiuse Music::MelodicDevice::Arpeggiation ();          # arpeggiosuse Music::Scales qw(get_scale_MIDI);               # pitches

Optional parameters

my %opt = (    port     => 'synth', # required MIDI device (e.g. microKORG or fluidsynth)    bpm      => 80,      # beats-per-minute    arp_type => 'any',   # 'any' or any known to the arp module    note_num => '5,7',   # number of notes to arp    repeats  => 1,       # arp repeats before the next one begins    spread   => 4,       # beats an arp should stretch across    octave   => '3,4,5', # octaves (0 .. 9)    tonic    => 'C',     # scale key base note    scale    => 'minor', # scale name as known to Music::Scales    program  => 0,       # synth program    channel  => 0,       # the MIDI channel);

Internal parameters

# one arpeggiator instance is reusedmy  = Music::MelodicDevice::Arpeggiation->new(    repeats => {repeats},    verbose => 1,);# used to rescale durationsmy  = Music::MelodicDevice::Arpeggiation::TICKS();# split thingsmy @octave    = split /,/, {octave};my @note_nums = split /,/, {note_num};my @arp_types = {arp_type} eq 'any'    ? keys ->arp_type->%*    : split /,/, {arp_type}; # see the Music::MelodicDevice::Arpeggiation docs# get full range of pitches by octavemy @pitches = map { get_scale_MIDI({tonic}, $_, {scale}) } @octave;die "No pitches for tonic={tonic} scale={scale}\n" unless @pitches;say "Arp types: {arp_type}";say "Arp nums: {note_num}";say "Pitches: @pitches";# we are in 4/4 time...my        = 4; # useful factor :)my  = 6 * ; # PPQNmy   = 60 / {bpm} / ; # time / bpm / ppqn# when spread is falsy, fall back to one bar's worth of beatsmy  = {spread} || ;my @active;  # { note => , off_tick =>  }my @pending; # { note => , on_tick =>  }my       = 0; # clock ticksmy  = 0; # beats!# open the MIDI device for outputmy  = out_port({port});->program_change({channel}, {program});say "Opened {port}";

Cleanup

# Ctrl-C clean shutdown{INT} = sub {    say "\nStop";    stop_all_notes(); # make sure all notes are off    exit;};

Loop and timer

# loop object to own and drive all timers/eventsmy  = IO::Async::Loop->new;# drive the whole sequencer  clock out, note off, note on, retriggermy  = IO::Async::Timer::Periodic->new(    interval   => ,    reschedule => 'hard', # anchor to a fixed schedule, don't let tempo drift    on_tick    => sub {        ->clock; # emit a MIDI clock tick        ++; # advance the master tick counter        # release any notes whose time is up        for my $i (reverse 0 .. $#active) {            # iterate in reverse so splice() below doesn't invalidate remaining indices            if ( >= [$i]{off_tick}) {                ->note_off({channel}, [$i]{note}, 0);                splice @active, $i, 1; # remove from the "currently sounding" list            }        }        # align to fire exactly on beat boundaries        if (( - 1) % $clocks_per_beat == 0) {            if ( % $phrase_beats == 0) { # retrigger every                 trigger_notes(); # start a new arp phrase!            }            ++; # only increment on beat boundaries        }        # collect every pending note whose start time has arrived        my @ready = grep {  >= $_->{on_tick} } @pending;        # keep the notes still waiting for a future tick        @pending  = grep {  <  $_->{on_tick} } @pending;        for my $p (@ready) {            ->note_on({channel}, $p->{note}, velocity(-10, 10, 110));            # remember the note, so the release loop above can turn it off at the right tick            push @active, { note => $p->{note}, off_tick => $p->{off_tick} };        }    },);->start;->add();->run;

Handy subroutines

sub trigger_notes {    # pick a random note count, then that many random pitches, sorted low-to-high for the arpeggiator    my @notes = sort { $a <=> $b }        map { [int rand @pitches] } 1 .. [int rand @note_nums]; # XXX clunky    # get an arpeggiated note list given a random arp_type    my  = ->arp(\@notes, 1, [int rand @arp_types]);    # convert from the arp's 96-ticks-per-quarter-note scale to our clock ticks    my @raw_ticks = map {        my () = $_->[0] =~ /^d(\d+)$/; # duration encoded as a string like "d96"        # rescale from the module's tick resolution to our own clock's ticks-per-beat        max(1, int( *  / ));    } @;    my  = 1; # default multiplier: 1 = no rescaling    if ({spread}) {        # total unscaled duration of the arp        my  = sum0(@raw_ticks) || 1;        # convert the desired spread (in beats) into tick units        my  = {spread} * ;        # factor that stretches or squeezes the arp's total length to exactly fill the available ticks         =  / ;    }    # anchor the first note of this phrase to "right now" of the master clock    my  = ;    for my $i (0 .. $#) {        my (undef, ) = @{ ->[$i] }; # a note is a duration and a pitch        # note's scaled length, floored at 1 tick        my  = max(1, int([$i] * ));        # schedule the note to be turned on/off        push @pending, {            note     => ,            on_tick  => ,            off_tick =>  + ,        };        # advance the cursor so the next note in the arp starts right where this one ends         += ;    }}sub velocity (00, , ) {    # generate a randomized velocity within [min+offset, max+offset]    my  =  + int(rand( - 00 + 1)) + 00;    return ;}

A superior implementation would use the Getopt::Long module to parse command-line arguments. Hint, hint. ;)

Audio examples

This is the General MIDI piano played with fluidsynth: Your browser does not support the audio element.Not terribly exciting, yet.The following were recorded with my microKORG synthesizer. But any MIDI-capable synth will do!This one sounds like an arcade. It repeats the arp twice: Your browser does not support the audio element.With an old-school sound and an already arpeggiated synth patch: Your browser does not support the audio element.Here is another: Your browser does not support the audio element.OK. How about an ethereal pad arping in slow motion? Your browser does not support the audio element.~And here is an example of the verbose console output that is produced:

> perl perl.com/arpeggios.plArp types: anyArp nums: 5,7Pitches: 48 50 52 53 55 57 59 60 62 64 65 67 69 71 72 74 76 77 79 81 83Opened midimate on program 21Repeat: 1, Type: pedal_down, Pattern: 6 5 6 4 6 3 6 2 6 1 6 0Ticks: 96, Duration: 8Arp: [  [ 'd8', 77 ], [ 'd8', 77 ], [ 'd8', 77 ], [ 'd8', 77 ], [ 'd8', 77 ],  [ 'd8', 67 ], [ 'd8', 77 ], [ 'd8', 65 ], [ 'd8', 77 ], [ 'd8', 53 ],  [ 'd8', 77 ], [ 'd8', 52 ],]Repeat: 1, Type: pedal_up, Pattern: 0 1 0 2 0 3 0 4 0 5 0 6Ticks: 96, Duration: 8Arp: [  [ 'd8', 50 ], [ 'd8', 53 ], [ 'd8', 50 ], [ 'd8', 53 ], [ 'd8', 50 ],  [ 'd8', 72 ], [ 'd8', 50 ], [ 'd8', 72 ], [ 'd8', 50 ], [ 'd8', 76 ],  [ 'd8', 50 ], [ 'd8', 76 ],]Repeat: 1, Type: down, Pattern: 4 3 2 1 0Ticks: 96, Duration: 19Arp: [ [ 'd19', 77 ], [ 'd19', 76 ], [ 'd19', 67 ], [ 'd19', 65 ], [ 'd19', 50 ] ]Repeat: 1, Type: down, Pattern: 4 3 2 1 0Ticks: 96, Duration: 19Arp: [ [ 'd19', 81 ], [ 'd19', 65 ], [ 'd19', 62 ], [ 'd19', 57 ], [ 'd19', 55 ] ]Repeat: 1, Type: pedal_updown, Pattern: 0 1 0 2 0 3 0 4 0 5 0 6 5 6 4 6 3 6 2 6 1 6 0Ticks: 96, Duration: 4Arp: [  [ 'd4', 48 ], [ 'd4', 60 ], [ 'd4', 48 ], [ 'd4', 64 ], [ 'd4', 48 ],  [ 'd4', 65 ], [ 'd4', 48 ], [ 'd4', 67 ], [ 'd4', 48 ], [ 'd4', 71 ],  [ 'd4', 48 ], [ 'd4', 76 ], [ 'd4', 71 ], [ 'd4', 76 ], [ 'd4', 67 ],  [ 'd4', 76 ], [ 'd4', 65 ], [ 'd4', 76 ], [ 'd4', 64 ], [ 'd4', 76 ],  [ 'd4', 60 ], [ 'd4', 76 ], [ 'd4', 48 ],]Repeat: 1, Type: random, Pattern: 0 3 3 2 2Ticks: 96, Duration: 19Arp: [ [ 'd19', 52 ], [ 'd19', 65 ], [ 'd19', 65 ], [ 'd19', 59 ], [ 'd19', 59 ] ]^CStop

The port that is opened is my MIDI interface to the microKORG, which is partly named midimate. It is worth pointing out that the out_port() function uses case-insensitive substrings/regexes to match MIDI device names.

Conclusions

You too can make MIDI music in real-time! And arpeggios are a highly useful technique for “filling the silence.”Timing events with async code takes quite a bit of logic. And sleeping is not an option.These techniques have wider usefulness. Knowledge of event systems is essential for programming graphical and interactive applications, high-concurrency network services, simulations, , and more! :-)

Resources

IO::Async::Loop
IO::Async::Timer::Periodic
List::Util
MIDI::RtMidi::FFI::Device
MIDI::RtMidi::Util
Music::MelodicDevice::Arpeggiation
Music::Scales
The code for this article: arpeggios.pl
The more complete and musical version: arping.pl
My original music is at https://geneboggs.bandcamp.com/ and https://www.youtube.com/@GeneBoggs

Some companies give AI to everyone. This CEO is doing the opposite

Furnished content.

Paysend CEO Ben Chisell limits AI tools to top performers as other U.K. companies push broader workplace rollouts.

Read more here

e dot dot dot 18 10 2026