Pandacap: Part 6 - Extras

There are a couple other areas of the Pandacap application that are probably worth drawing attention to.

Pandacap: Part 4 - Inbox

Although it's not public-facing, the Inbox is perhaps the most useful part of the Pandacap web app. As a descendant of Artwork Inbox (Pandacap is built on EF Core + Cosmos DB in a very similar manner), the Pandacap inbox pulls in new posts from ActivityPub, Bluesky, DeviantArt, RSS/Atom, and Weasyl, and allows the logged-in user (me) to view and dismiss them, kind of like an email inbox.

Posts from users and feeds you follow are split between four different inboxes:

• Image posts: DeviantArt and Weasyl art submissions, and any ActivityPub, Bluesky, and RSS/Atom posts that have an image attached. (Unlike the Pandacap gallery, these aren't called "artwork" posts, because Pandacap can't tell whether an image post is "art" or not.)
  
• Text posts: DeviantArt journal entries and status updates, and any ActivityPub, Bluesky, and RSS/Atom posts that don't have an image.
• Shares: If an ActivityPub and Bluesky post is showing up in your feed because it was shared / reposted / boosted by the user you follow, it will be sent here, instead of to the image post or text post sections. Pandacap will group shared posts by the user who shared them, not by the user who originally posted them.
  
• Podcasts: RSS/Atom feeds that have an attached audio file will be sent here.

The user experience here is heavily inspired by the Fur Affinity and Weasyl inboxes: posts are shown roughly in chronological order; image posts have thumbnails and text posts only have a title; you have to click through to see the description / body of the post; checkboxes are used to remove posts from your inbox; and a "next page" button is used instead of a dynamic loading of new content.

Pandacap: Part 2 - Authorization

Since Pandacap is a single-user application, I really didn't want to write my own authentication and authorization system. The only goal was to allow myself to log in, and no one else. So instead of using an email/password combo, like the default Identity template, I've limited it to just this:

I recently expanded my triple-boot PC to boot four operating systems off the same drive: DOS, Windows XP, Windows 7, and Debian.

Generally, in the old BIOS world, you'd handle this by having GRUB (controlled and configured by the Linux installation) as the main bootloader, and let it boot Windows and DOS from there. But I like to take a more unconventional method (detailed here) where I have the newest installed version of Windows control the main bootloader, and let Linux boot from DOS.

There were three big changes I made this time.

First, I kept Windows XP and Windows 7 both installed to separate extended partitions. I believe they both install their bootloaders to the DOS partition - I know Windows 7, by default, won't map it to a drive letter because it assumes it's just a system partition (you can change this from Disk Management).

To limit the number of consecutive menus, after installing Windows 7, I removed FreeDOS from the boot.ini used by Windows XP's bootloader (ntldr) and added it to Windows 7's (bootmgr). The bootsect.dos (extracted and created by Windows XP's installer) can be loaded through bootmgr by adding a new entry:

bcdedit /create /d "FreeDOS 1.3" /application bootsector
bcdedit /set {new-guid} device partition=e:
bcdedit /set {new-guid} path \bootsect.dos
bcdedit /displayorder {new-guid} /addlast

Options like /displayorder or /default can be used to customize its spot in the menu.

But most importantly, I still wanted Debian to boot from DOS so it wouldn't touch the MBR (making it easy to delete or replace from within DOS/Windows without breaking anything). But instead of installing grub-legacy in Debian to generate the menu.lst and using GRUB4DOS to boot it (which I'm sure would have worked fine), I wanted to use a method of booting Debian that would rely only on the partition GUID, and not on the drive number.

When converting recorded ATSC 1.0 (over-the-air) broadcasts to video DVD format using devede, I've noticed the audio/video sync ends up a little off.

Re-encoding the audio seems to fix this:

ffmpeg -i input.mts -c:v copy -c:a aac -ac 2 output.mkv

This keeps the video data intact, and just re-encodes the audio (as stereo, not the original surround sound).

These sorts of broadcasts usually have an alternate audio track as well - you could use some -map arguments to pick the track(s) you want, but I didn't bother with that this time around.

After doing this, I can put the resulting file into devede :)

If that doesn't work, here's a script that will convert the closed captions to subtitles and re-encode the video. Sometimes this can be necessary - an over-the-air data stream is sometimes missing some data that automated scripts can run into problems with.

#!/bin/sh
set -e
for i in $*; do
	o="$(basename $i)"
	m="$o.mp4"
	if ! [ -f "$m" ];then
		chmod +r "$i"
		ffmpeg -i "$i" -c:a copy -c:v copy "$o"
		ccextractor "$o" -in=ts -out=srt
		ffmpeg -i "$o" -c:a aac -ac 2 -c:v libx264 -preset veryfast "$m"
		rm "$o"
	fi
done

Recently I bought a travel hub for my laptop (up 'til now, I'd been using my work laptop's Thunderbolt dock, but I thought it would be nice to have something I could bring with me.) It has a USB-C plug and a small collection of ports:

• Left:
  
• HDMI out
• SD and microSD card reader
• USB-C (power input)
• Right:
  
• USB-C (not Thunderbolt)
  
• USB-A (2x)
  

These sorts of hubs have become widespread with the rise of laptop computers (and tablets/smartphones) with nothing but USB-C ports. USB-C is still seen as something of a new, shiny technology (after all, it didn't even exist ten years ago!) So out of curiosity, and a sense of playfulness, I decided to try plugging the hub into my Dell Dimension 4700, a computer designed almost twenty years ago.

The HDMI port didn't do anything, of course, but everything else worked almost perfectly.

In 2004, it was the early days of PCI Express, and the Dimension 4700 came with two PCI Express slots: a long slot for the graphics card, and a spare one-lane slot. And since PCI Express is, of course, still a thing, it's not hard to get your hands on a PCIe card that gives you a couple of USB 3 slots... and then add a front panel with USB-A and USB-C ports. (After all, USB-C at its core - if you're not using any alternate modes - is still USB, maybe with a bit of extra circuitry for detecting plug rotation.) My PCIe card uses a VL805 chip and provides a header for the front panel to connect to, along with a power input - otherwise, the 4700 doesn't give enough power over PCIe to run the card, the front panel, and a spinning disk hard drive. (I bought this card after learning that - but the old card found a home in a relative's PC, to add a couple extra ports to the back.)

The USB-C connector normally provides pins for a USB 2.0 link and two USB 3.x links, but if DisplayPort Alternate Mode is used, one or both of the USB 3.x links can be repurposed for a DisplayPort connection. This explains why you see a similar port selection on so many of these hubs, and why you can't just plug another HDMI or DisplayPort adapter into the USB-C data port on them. I imagine the only real logic the hub has to handle is power delivery (whether from an external source or from the host device) - everything else can be built from just a hub (using the USB 3 link and the USB 2 link), a card reader (attached over USB), and a DisplayPort to HDMI adapter, all of which are commonplace.

Thunderbolt docks work differently. There's a lot more active circuitry in those - it lets you have a higher bandwidth connection (and the flexibility to daisy-chain another Thunderbolt or USB-C device), but it's really working at a higher / more abstract level in order to make that happen. Not surprising that the Thunderbolt dock does nothing when plugged into the 4700!

Working in .NET, I've been in a situation where I need to implement a function in an interface that's supposed to return an IEnumerable<T>. (In some cases, I'd argue that IReadOnlyList<T> might make more sense - this way, the caller knows it's not going to be a lazily-evaluated sequence, and you can still return a .NET list, F# list, or array - but I digress).

Maybe the most obvious way to do this is by calling a function that explicitly returns an empty enumerable for you:

IEnumerable<string> SampleInterface.getAll() => Enumerable.Empty<string>();

In F#, it would be even shorter, because of the aggressive type resolution:

interface SampleInterface with
    member _.getAll() = Seq.empty

There are other clever ways to do the same thing, though, and it might just depend on what you think is the clearest or most readable - which might just mean keeping it consistent with the code around it. First, you can always expand out the function (because clearer isn't always shorter - I think it really does depend on the context of what's around it):

IEnumerable<string> SampleInterface.getAll() {
    return Enumerable.Empty<string>();
}

But there's also something clever you can do here, if you want to think of your code in a different way - where instead of resulting in "an empty list", it results in "no elements". C# lets you build iterator functions, where your code defines an IEnumerable<T> (and runs every time the resulting object is enumerated). Any function with a yield return or a yield break is treated in this way by the compiler. This means you can implement a function that returns "no elements" just by doing this:

IEnumerable<string> SampleInterface.getAll() {
    yield break;
}

It's a bit different in VB.NET, where iterator functions are denoted explicitly - so the yield break isn't needed:

Public Iterator Function getAll() As IEnumerable(Of String) Implements SampleInterface.getAll

End Function

That is, in a very literal sense, a function that returns no elements!

Funny thing is that there's no real equivalent to an empty iterator function in F# (not that you'd need it); the compiler won't allow a seq { } workflow without any elements in it, and suggests you use Seq.empty or the empty list [] instead.

// UTF-32 is a Unicode encoding that uses exactly four bytes for each
// codepoint. Unlike UTF-8 (used widely on the Web) or UTF-16 (used in Java
// and .NET), each codepoint / character takes up the same number of bytes,
// making it much easier to do string processing (counting, substrings) based
// on character count.

// One common application is applying styling or custom behavior to Twitter
// posts based on the data provided by the API:
// https://developer.twitter.com/en/docs/twitter-api/v1/data-dictionary/object-model/entities

Let's say you want to embed some videos on your website, and you want to put them in a list so people can click through and watch them.

The title, description, and thumbnail you give to the video are largely subjective decisions, but the duration - in minutes and seconds - is an objective property of the media itself, which means you should be able to extract it if you know the video's URL. But how exactly do you do that?

Well, the first thing you'll need to do is figure out what exactly you're dealing with: a raw video file (or stream) that plays in the browser's <video> tag, or a link to a page on a site like YouTube or Vimeo that hosts embeddable content. Technologically speaking, it's an entirely different beast. A YouTube page gives you the code for a player, and wraps all of it up with copy protection and a variety of other features specific to the platform. In other words, it's not handing the end user something to play; it's playing it for them. It's kind of like the difference between having a record of a song, and having a band come over with their own instruments to play it on.

That doesn't mean they can't serve the same purpose for the end user of your site, though, and in both cases it should be possible to programmatically determine the duration of the media. I've written a .NET library (ISchemm.DurationFinder) that handles this for you for a variety of common video types with just a URL; I'll walk through how it works overall, and how it finds the duration for each type of media that it supports.