#Today I learned Peggy Parish's nephew wrote more Amelia Bedelia books than she did. Like more than 2/3 of the series, as it is now.

Here's a new one for activitypub quirks. Hubzilla only puts as:public in the create, not the note? Somebody (presumably a follower) booped it, and I could fetch it, but it shows up as not public here. So no further rebooping from me.

I was curious, but it turns out these two constructs have identical character counts (in this example).

array.Map(func(elem Type) {
    // code
})

for _, elem := range array {
    // code
}

Well, hello there, #iwm 9k ​

# ifconfig iwm0 scan | grep nwid | wc -l
52

Found a new one today.

Location: 39.96 -75.16

I want more fall weather. Not ready for didn't your mother tell you to wear a hat weather yet.

#opengl is now 27 years old and I can still hang the whole system by calling glBindTexture from two threads concurrently. As an "unprivileged" user.

KDE still ships a CVS frontend and makes people update it regularly

I like when a mastodon instance's queues get jammed up and it sends out the Create parts of a 4x delete and redraft but not the Delete parts so I end up with a feed full of the same post.

People who really need an edit button should consider using a fediverse platform that has an edit button. Just saying.

Diskless booting OpenBSD on a MVME167 in 2019

Softwares setup

We will uses a virtual machine with Devuan on VirtualBox, download it and setup two interface cards:

• eth0: NAT
• eth1: BRIDGE to your ethernet card

Asumptions

Your server is going to be named "laptop" with the IP "10.0.0.1". Your MVME167 board is going to be named "mvme167" with the IP "10.0.0.2" The MVME167 board will have the mac "08:00:3e:22:77:53" The latest OpenBSD with m68k support is 5.5

Boot the VM and start the setup:

Network

Add in /etc/network/interfaes:

auto eth1
iface eth1 inet static
    address 10.0.0.1
    netmask 255.255.255.0

RARPD

apt install rarpd

Create the file /etc/ethers with:

08:00:3e:22:77:53    mvme167

Add in /etc/hosts:

10.0.0.1    laptop
10.0.0.2    mvme167

Add in /etc/hosts.allow:

ALL: 10.0.0.0/24

Add the following in bottom of /etc/default/rarpd:

OPTS="-e -v eth1"

Restart service:

/etc/init.d/rarpd restart

RPCBIND

apt install rpcbind

BOOTPARAMS

wget http://ftp.de.debian.org/debian/pool/main/n/netkit-bootparamd/bootparamd_0.17-10_amd64.deb
# or newer if any
dpkg -i bootparamd*.deb

Edit /etc/init.d/bootparamd and add -r 10.0.0.1 on end of lines 30 and 42, the ones with start-stop-daemon --start.

Create /etc/bootparams with:

mvme167    root=10.0.0.1:/srv/nfs/root

Restart service:

/etc/init.d/bootparamd restart

NFS (v2)

apt install nfs-kernel-server
mkdir -p /srv/nfs/root

Edit /etc/default/nfs-kernel-server and change:

RPCNFSDCOUNT=...
# by
RPCNFSDCOUNT="8 --nfs-version 2,3,4"

Create /etc/exports:

/srv/nfs/root    10.0.0.2(rw,sync,subtree_check,no_root_squash)

Restart service:

/etc/init.d/nfs-kernel-server restart

TFTPD

apt install tftpd-hpa

OpenBSD Root FS and TFTP

cd /srv/tftp
wget https://ftp.nluug.nl/OpenBSD/5.5/mvme68k/netboot -O netboot.mvme68k
cd /srv/nfs/
wget https://ftp.nluug.nl/OpenBSD/5.5/mvme68k/{base55,comp55,etc55,man55}.tgz
cd root
tar xzvf ../base55.tgz
tar xzvf ../etc55.tgz
tar xzvf ../comp55.tgz
tar xzvf ../man55.tgz
wget https://ftp.nluug.nl/OpenBSD/5.5/mvme68k/{bsd,bsd.rd}

MVME167 configuration

NIOT

Change the following values:

Client IP Address      =10.0.0.2?
Server IP Address      =10.0.0.1?
Subnet IP Address Mask =255.255.255.0?
Broadcast IP Address   =255.255.255.255?
Gateway IP Address     =0.0.0.0?
Boot File Name ("NULL" for None)     =netboot.mvme68k?
Argument File Name ("NULL" for None) =bsd.rd?
Boot File Load Address         =006F0000?
Boot File Execution Address    =006F0000?

Save it to NVRAM if you have configured your ENV for it.

Then execute a NBO NetworkBOt and OpenBSD should boot to the installer.

I'm going to have to add necrothread resurrection to honk just to see what all the fuss is about.

A bug report in which #openbsd is not #posix compliant when dealing with a user specified CAT timezone.

https://marc.info/?l=openbsd-bugs&m=157379849727998&w=2

Sigiriya, Sri Lanka.

I like that the hyperbola freedom package conflicts with all of rust to ensure your privacy.

https://www.hyperbola.info/packages/core/any/your-freedom/

https://consoledonottrack.com/

Dafuq?!?

really freaking long

A nice evening read. Not sure I'd recommend reading before going in to work, though.

https://twitter.com/mcfunley/status/1194713711337852928

@mcfunley: Mute me for a bit if you don’t like long diatribes about startup debacles but this reminds me of a story (1/n) https://twitter.com/kellan/status/1194633626161299465

@mcfunley: So the first version of Etsy (2005) was PHP talking to Postgres, written by someone learning PHP as he was doing it, which was all fine. Postgres was kind of an idiosyncratic choice for the time, but it didn’t matter yet and anyway that’s a different story.

@mcfunley: I started in the long shadow of “v2,” a catastrophic attempt to rewrite it, adding a Python middle layer. They had asked a Twisted consultant what to do, and the Twisted consultant said they needed a Twisted middle layer (go figure).

@mcfunley: The initial release of this resulted in two full weeks of downtime, and an infamous incident where one of the investors had to drive to Secaucus to physically remove the other engineering founder from the cage.

@mcfunley: He had been there for days I guess and was threatening to drop the master database, for which there were no backups. Nobody learned anything from this.

@mcfunley: Anyway, people were understandably really mad at this middle layer, but nobody agreed on the reason to be mad. And nobody was in charge, so there were several concurrent attempts to destroy it in competition with each other.

@mcfunley: The team thinking it would rewrite the whole site in Django morphed into a team thinking it would rewrite Django first, and then rewrite the site in the result. There was one guy trying to rewrite the site in Java.

@mcfunley: Either of these scenarios may have been worse than what transpired, which was that the team trying to rewrite the middle layer with a drop-in replacement won the political struggle and ate all of the other teams.

@mcfunley: The theory of the drop-in team was that the existing middle layer was bad because although it used Twisted, it still used a threadpool. (Twisted is a reactor loop like nodejs, but in Python.) For Twisted acolytes, this situation was heretical.

@mcfunley: So the drop-in team was trying to recreate the same middle layer, but using the reactor loop faithfully. And the theory was that’d solve all of the problems with the existing middle layer bringing the site down constantly.

@mcfunley: The middle layer didn’t really do anything. It was consultant-provided speed holes which (it was believed) would make things faster by (counterintuitively) adding network hops. https://pic.twitter.com/NHviSrLLPI

@mcfunley: The middle layer just received RPC and invoked postgres stored procedures. Which, if you have a superficial understanding of things, seems like the kind of boilerplate you can replace with an abstraction.

@mcfunley: So the drop-in team wrote a declarative framework for making these RPC endpoints. Then they proceeded to discover that here in reality every single existing endpoint did things differently. https://twitter.com/kellan/status/1194633772253106176

@mcfunley: To ensure bug-for-bug compatibility, they made me and several other people write detailed a detailed test suite for six months. As predicted in Kellan’s tweet above, the job of writing the server was separated from the dirty work of implementing the “business logic.”

@mcfunley: “Business logic” being a term of art which means “your bullshit”, in contrast to “my code,” which is beautiful.

@mcfunley: (By the way this was all SO much better than the financial industry job I had before this.)

@mcfunley: When we finished, what we had was a Twisted-pure version of the middle layer. Plus a declarative framework which just added lines of code, since declaratively specifying a thousand special cases requires more code than not having the framework at all.

@mcfunley: This is a generalizable part of the experience for me—if I could choose a superpower it’d be to appear like Candyman behind any developer saying “it should be easy to make a declarative framework for this.”

@mcfunley: The drop-in was also written in callback style with Deferreds, so although logically it was identical to the first version, it was roughly triple the line count and much harder to grok and debug.

@mcfunley: If you forgot to return a Deferred, you were shit out of luck since the language obviously couldn’t help you with it.

@mcfunley: But eventually after months and months we released this thing on one page, and it burst into flames within milliseconds.

@mcfunley: I don’t know what the state of the art is with debugging and profiling nodejs these days. But whatever that story is, I assure you that understanding what a Python reactor loop was doing while it was melting down in 2007 was the bronze age by comparison.

@mcfunley: I saved this screenshot of helplessly waving kcachegrind at it and hoping for a miracle https://pic.twitter.com/L1IZqSazgv

@mcfunley: It was at this point that the Twisted consultants were brought back

@mcfunley: They said that although Twisted was good at overall throughput, outlying requests could experience severe latency. Which was a problem for the drop-in, because the way the PHP frontend used it was hundreds/thousands of times per web request.

@mcfunley: “Yeah sorry folks it’s not good for this.”

@mcfunley: So over the course of a few weeks we frantically rewrote the drop-in replacement to use a threadpool instead, exactly like the original heretical one.

@mcfunley: Leaving us with literally the same code as the thing it was dropped in to replace, plus a ridiculous declarative framework, plus some tests. It was around this time that everyone got fired (but not me).

@mcfunley: One way to look at this is that an entire engineering and ops team lost their jobs because a group of people thought that threads were Wrong.

@mcfunley: By the time the drop-in replacement was being systematically eradicated by the drop-in replacement engineering team, this entire saga had been forgotten because it was simply too out there to be believable. https://www.youtube.com/watch?v=eenrfm50mXw

@mcfunley: As a younger person I had no power to avert any of this, but I managed to not get fired because through this whole thing I was talking shit about it. Which was not necessarily the lesson I needed to walk away with, but here we are. /end

It just... decided to work ???
tjXje_wmIHhacQ.jpg

Another #security article about the intel disclosure and embargo timeline. Or to quote Dave Aitel: "This is what responsible disclosure looks like when you take its makeup off"

https://www.nytimes.com/2019/11/12/technology/intel-chip-fix.html

When you need to be creative with your socket
image.png

Wikipedia deadnaming Kyiv.

https://en.wikipedia.org/wiki/Kiev

Tamper cover for the drop off shred box, though I'm not sure how secure it actually is. Still perplexed how offsite shredding is even a thing. Especially here, where you have to carry all your zecrets outside down the street, hope you don't trip and spill them everywhere, then come inside the store and pay to put them in the naughty box. #opsec

I love the weird little easter eggs that programmers have always put in their programs. Like this remote job entry program by RAND Corporation in 1972 which featured a "BYE, BYE BANANA" message when you quit.

https://write.as/365-rfcs/rfc-307

Suspicion of palmetto poaching not grounds for terry stop.

http://media.ca11.uscourts.gov/opinions/unpub/files/201911475.pdf

A button I'm not clicking.

DZ: no more pornpal

Not my usual blog fare, but... PayPal has stopped all Pornhub model payouts.

Maybe want to take care not to scroll too far into the comments section.

https://www.pornhub.com/blog/9122

DZ: preposterously long twitter thread about floppy drives and retro storage

Somebody patreon this guy a real blog please.

https://twitter.com/Foone/status/1194762568948056064

@Foone: So when you format a floppy disk you can pick between full and quick format, and I think I only really understood the difference and what "full format" does relatively recently. SO A THREAD https://pic.twitter.com/nhYwijVKKW

@Foone: At a high level: Quick format doesn't format the disk, it just erases the file metadata by setting up a new FAT12 filesystem. Full format actually formats the disk and erases all the content, and also sets up a FAT12 filesystem.

@Foone: And the confusion comes down to how "formatting" really means three things: Low Level Formatting High Level Formatting Creating the Filesystem

@Foone: Basically, for quick formatting, you only do #3. But what are the other two? And confusingly, "formatting" is different for hard drives, and different for both kinds of hard drives.

@Foone: So let's start by explaining how a memory card stores data. An old memory card, one that isn't Smart... even if it's called a "Smart Media Card". https://pic.twitter.com/kVJMYIHuYJ

@Foone: This uses flash memory, which uses a bunch of little transistors that can store a tiny charge. They're grouped together into "pages" which you read/write at once, and those are grouped into sectors, which is how the PC reads and writes them.

@Foone: But these sectors are physical things: it's a grouping of transistors. It starts at sector 0 and goes to how ever many sectors the device has. In the case of this 32mb one and standard 512-byte sectors, that's 65536 sectors.

@Foone: So to format it, you could go through and write the same value to all those sectors, making it blank. Additionally, you set up the filesystem, where there's FAT12 headers at the start, telling you where files are/will be. And you're done. That's formatting.

@Foone: Part of the problem with understanding this is that basically all data storage devices pretend they work like this in the modern day, in order to make things simpler. Sectors 0 to MAX, you can write them, read them, and that's about it. They're there before you format it.

@Foone: So modern flash memory (SD cards, USB sticks, and SSDs) make this more complicated, while still pretending it works this way. With flash memory, each cell has a limited lifespan measured in a number of writes, so to avoid wearing a cell out, they do wear leveling.

@Foone: Basically there's a tiny computer inside the memory chip that translates between the sector number you request and the internal sector number, and external-sector-to-internal-sectors mapping can change, to evenly use the entirety of the memory card.

@Foone: the idea is that this is hidden from you and the memory card acts just like it doesn't do this, except the memory lasts a lot longer.

@Foone: And so onto hard drives: Spinning-rust hard drives don't work like this at all, but since Logical Block Addressing they pretend to. They have some number of sectors, and your PC sees 0-MAX sectors, with no info about where they are.

@Foone: But inside, your hard drive is a stacked pile of 1 or more circles of magnetic material, with an arm that can move the drive heads in and out, and it spins. https://pic.twitter.com/47TofdmUex

@Foone: And the way this works is explicitly named in the old CHS scheme: "Cylinder/Head/Sector" Cylinder selects which circular track to use (further in or farther out), head selects which read head to use (top/bottom of each disc), and sector (which little segment of that track) https://pic.twitter.com/7HHSiLyFp7

@Foone: But because of LBA, the PC just sees this as a series of individual sectors, and the hard drive controller can convert those into an actual physical location on disk... OR CAN IT?

@Foone: So look at this hard drive platter. Do you see sectors? or tracks? NO! they are invisible. And how did they get there, anyway? are they physical structures, like the grove on a record? are they magnetic? or are they entirely logical? https://pic.twitter.com/rI8kJi6rnv

@Foone: So it turns out the answer is that they're magnetic! and they're on the disc from the factor, but not when the disc platter is created. The platter is the same all across, but there are servo markings on them

@Foone: Servo markings are put down on the disk at the factory, using a super-accurate system. They mark out where the tracks are and where the sectors are, and the head can use them to navigate around the disk: it finds the right track, then waits for the right sector to rotate around

@Foone: And importantly, modern hard drives cannot put these servo tracks on the platters themselves. You used to be able to do it (back when hard drives were in the 40mb range!) but now it's designed so that it's not needed

@Foone: and making it not be needed saves on cost for the drive, as it only has to be accurate enough to find a sector, not accurate enough to put it down in the right place to begin with.

@Foone: And so, back to formatting: The putting down of these servo tracks is called low-level-formatting, so when you "format" a modern hard drive (meaning anyone since like 1991) you only do the high-level-formatting and the making of the filesystem. Low level has already been done

@Foone: BTW, this also means that if your hard drive gets erased by a magnet, you can't fix it. Those servo tracks can't be rewritten, and they're gone permanently. (Fortunately that doesn't really happen: the hard drive wouldn't really be affected by most magnets)

@Foone: OK SO that's how it works on flash and hard drives, let's go back to floppies. The floppies used with PCs (both 5.25" and 3.5") are what's called soft-sectored. There are no servo tracks.

@Foone: So the servo tracks in a hard drive are needed for two things: 1. to find the track (moving the head in and out) 2. to identify the sector (as it rotates around)

@Foone: Hard drives need them for #1 because they use a voice coil. It's positioned based on the current going through it, and it's analog. So different amounts of electricity positions it at different positions, and it uses the servo tracks to figure out where it is and adjust. https://pic.twitter.com/kESjNTPpWy

@Foone: floppy drives, on the other hand, use stepper motors. Stepper motors have a system where you can adjust how the motor turns, in 90-degree steps. So by using it with a worm drive, it can position the head in discrete steps. https://pic.twitter.com/vtDOplXqFs

@Foone: So to figure out how far to move to a track, you just need to know where you currently are, and then count how many steps to make and in which direction. So if you know you're on track 5, track 7 is just 2 steps up.

@Foone: But you have to figure out where are to start with. This is done in two simple ways, depending on the drive: 1. Go down one track until you trigger a track-zero sensor 2. Go down more tracks than the disk has.

@Foone: 3.5" PC floppy drives have a track zero sensor which detects when the track hits the minimum position. So when it starts up, it just goes down until that sensor activates, then it knows it's on track 0, then it remembers which track it's at from then on. https://pic.twitter.com/pkjF0KQyRf

@Foone: Apple II disk drives, on the other hand, save money by not having a sensor. They just know that Apple II disks have 35 tracks, so when they power on they go down 35 tracks, so no matter what track they started on, they're on zero now. https://pic.twitter.com/Q59AXr02Hk

https://twitter.com/Foone/status/1194773339941687296

@Foone: You know that THUDTHUDTHUDTHUDTHUD noise when an Apple II boots up? That's the drive head hitting the zero-position and failing to got back any farther. https://www.youtube.com/watch?v=Dub4nraPLlQ

@Foone: OK SO: Floppy drives don't need servo tracks to know where tracks are. How do they know where the sectors are? If you just start reading at any point, you'll find some data, but is it the sector you want? the second half of another sector? HOW DO YOU START?

@Foone: and the answer is, as you might have guessed: low level formatting!

@Foone: When you format a floppy, you're not just doing the "write each sector with a blank sector" part, like you'd do with a hard drive or flash storage device, you're also creating the sectors.

@Foone: so the actual magnetic format on disk is going to be something like: [sector header for sector 1][sector data][sector footer] [inter-sector gap] [sector header for sector 2][sector data][sector footer] [inter-sector gap] ...

@Foone: each sector header has info like what track it's supposed to be on, which sector number it is, and the checksum of the sector (which may be in the footer, depending on the format)

@Foone: this checksum, btw, is how you can tell the difference between a floppy disk that has been magnetically erased and formatted. A formatted disk will have blank sectors with accurate checksums, an erased disk will have no sectors or corrupted sectors.

@Foone: But as the floppy is spinning around, this gets written out like it's a linear tape, until it completes a full rotation. It just writes the sectors with metadata and the gaps between the sectors, going all the way around.

@Foone: BTW, the metadata here isn't things like "what file is stored here?" it's just to let the drive locate the sector itself. Things like filesystem info is stored as data inside sectors, not inside their metadata.

@Foone: and the gaps are very interesting: You'd think you wouldn't want gaps, because that's parts of the magnetic surface that you're not using. it's wasted storage space! But the problem is that disks are read-write devices, and they're not perfect.

@Foone: imagine you write out a disk with three sectors, with no gaps, back to back, like: [sector 1][sector 2][sector 3] Now you need to rewrite sector 2. Uh oh. You have to time this PERFECTLY or you'll overwrite part of sector 1 or sector 3 because of the positioning!

@Foone: And it's a timing thing because, to paraphrase something 4am said, the disk keeps spinning no matter what the CPU is doing. If you take too long or not long enough, your head is in the wrong place.

@Foone: So inter-sector padding gives you some slop so you can safely rewrite a sector without risking stepping on the sectors around it.

@Foone: You could, in theory, read the entire track into RAM, replace the sector in RAM, then write the whole thing back out... but that's like 16-32 kilobytes of data (for a 1.44mb disk). That's a lot of RAM! It's also slow. You'd have to rewrite the track every time you write 1 sector

@Foone: so in practice the only things that ever did track-at-once writing were things like disk duplicators, which were specialized.

@Foone: SO, to summarize how this works: When you format a floppy disk, you do three things: 1. Decide where the sectors will be (on each track) by writing their headers/footers 2. Write blank sectors, effectively clearing the disk. 3. Create a filesystem inside those sectors

@Foone: But 1 and 2 are discrete steps, even if they will (in practice) be merged when doing this. Your disk controller doesn't actually write a sector and then re-write it to be blank, it just writes it blank in the first place.

@Foone: And it's important to realize they're discrete steps because they're not done in all situations, even when we're talking about "formatting". Format a hard drive, and there's no low-level formatting being done.

@Foone: Interestingly this is also true of some types of floppies! Zip Disks, for example, use servo tracks. This is one of the ways they store so much more data than a 1.44mb disk https://pic.twitter.com/WeYZoSpAVA

@Foone: And it's also true in some optical discs. Optical discs are usually read-only and just have one long spiral track (like a vinyl record) but they use something similar to let the head determine where it is on the disc. But in writable discs, it's different.

@Foone: Your CD-R stores data using a pregroove (created when the disc is created), which the head of the drive follows as it burns or doesn't burn the dye in small segments along that groove, affecting the reflectivity and allowing it to be read later. https://pic.twitter.com/hHbqb6uqji

@Foone: The simplest way to do this is "disc at once" mode: It starts at the beginning and follows the whole groove until the end. But there's also "track at once", which only does a part of the disk, allowing more data to be added later.

@Foone: importantly, "tracks" in this case are fully virtual things. The table of contents of the disc says where they start and end, based on which sectors belong to which tracks. Like: Track 1: sectors 1-2000 Track 2: sectors 2001-6000 Track 3: sectors 6001-9999

@Foone: But they're not the only optical writeable discs: there's also Magneto-Optical disks, and they're hard sectored. Instead of needing to low-level format them, it's encoded into the disc itself.

@Foone: and the cool part? Those sectors are VISIBLE! If you open a magneto-optical disk you can see exactly where each sector starts and ends. https://pic.twitter.com/vJFKPnz5Cm

@Foone: but yeah. This whole thread was basically just to explain the background to show how I went through multiple levels of understanding about what "formatting" a floppy meant over 25 years of dealing with this shit

@Foone: 1. what's formatting? 2. formatting is erasing all the files 3. formatting is writing blank bytes/sectors to the disk 4. formatting is creating the sectors, so the drive can find/read/write them again later

@Foone: BTW, the fact that formatting a floppy drive is #4 and not #3 actually indicates something about what you should do if you get a bad sector on a disk.

@Foone: if you think of formatting as just writing zeros(/blank sectors), if you get an error then that must mean the disk itself is bad, physically. throw it out!

@Foone: but when you understand that it's creating the sectors, you can see that you might get an error writing a sector because THAT SECTOR ISN'T THERE ANYMORE (thanks, magnets) and the disk itself will be fine, once you reformat it again.

@Foone: admittedly, NOT the most useful thing to know in 2019, even for me. But hey, it's good to know.

https://twitter.com/Foone/status/1194782997779636225

@Foone: Anyway, if you liked this Old Tech Rant, feel free to give me a dollar or two on ko-fi: https://ko-fi.com/fooneturing

@Foone: or set up a monthly donation on patreon: https://www.patreon.com/foone

@Foone: or get one of my weird art PCBs on etsy: https://www.etsy.com/listing/736823648/copyprocontrol-pcb-v12

@Foone: and you might like to read my older thread on how CHS turned into LBA in PC hard drives and the weird hack we did to make that transition smother: https://twitter.com/Foone/status/1165455650823950337

@Foone: BTW, I was taking special care to say "blank" sector instead of "zeroed" for most of the thread, because the DOS format command doesn't erase it to zeros: it uses 0xF6. This has no real practical impact but is definitely a thing, so it's the perfect piece of trivia.

Just occurred to me today that you younger folks who have the benefit of awesome tools like #blender might not even know that POV-RAY exists.

Pretty amazing what people are doing with this stately old piece of code these days. Check out the hall of fame, I think you'll find an image or two to be impressed by!

Many years ago, when computers were crawling, embryonic half formed things compared to what we use today, this thing was AMAZING and let anyone ray trace. It was *empowering*.
http://hof.povray.org/

Apropos nothing, it is really astonishingly difficult for me to navigate from a gitlab pull request to the actual commit diffs. Like a rat in a maze, except I never learn anything about where to go.

I like how go requires trailing commas and eslint forbids them in object literals.

MRF to rewrite all mentions in a post into a minimal DFA.

#Today I learned Escape (The Piña Colada Song) is the only song to be a #1 hit in two decodes. It ended 1979 topping the charts, was displaced to #2 for the first week of 1980 by KC and the Sunshine Band, then returned to #1 the week after.

Shadow box for images that requires the user to type :q to close.