Tag Archives: Ubuntu Linux

“Windows cannot find a critical file.” Current Rage Level: Omicron.

Ubuntu Linux: the Wal-Mart(TM) Frontier. These are the voyages of the Spacecar
Grosvenor. Its continuing mission: to allocate new structs & new classes, unite
all people within its nation, and leak where memory has never leaked before.

Of the numerous Linux installations ("distributions"), I've used Ubuntu Linux (published by Canonical Inc.)
most. It contains the Linux kernel, the GNU core utilities, and several other
items of interest such as an automagically-configured graphical user interface.
It is extraordinarily user-friendly, to the point of feeling constrictive. (The
desktop environment has changed since version 11: users now cannot reconfigure
the taskbar or workspaces. The repository wants to be a dime-store, too, and
although a potentially lucrative storefront I miss the simplicity of Synaptic.)

Its installation procedure is simple: download a Live CD image from Canonical's
Web site, burn it to a CD-R or RW (these days, you might even need a DVD), and
reboot your machine with the disk inserted. (Don't forget to tell the BIOS -- er
whatchamacallit, the Extended Firmware Interface -- to boot from CD.) You'll be
presented with an operable temporary login. Thence you can install the OS. Also
available from this interface was an option to create a USB startup disk, but it
has been removed in recent revisions of Ubuntu: previously, using VirtualBox or
any similar virtual machine, the user could run the LiveCD & make a startup USB
without even rebooting out of their present operating environment, which was
useful on old machines whose optical drives had failed. You can still "Install"
to the USB key, but it boots slowly & you can't install it from there to a box.

The installation wizard is a no brainer: "install alongside Windows." Easy! And
it usually doesn't cause your existing Windows system to go up in smoke, either.
However, to install Ubuntu more than once per box, you must repartition manually
(and may also need to change grub: see /boot/grub and /etc/grub.d). Gparted is
included within the live disc images, but must be retrieved again after install.

If you'd like to make intimate friends with the manual pages, and discover where
primary partitions go when they die, you can install with less assistance. This
lets you specify partitions in which to mount your home & system directories, in
case you'd like to keep them segregated. (That's probably a great idea, but I
never do.) You can also create and specify swap partitions: which are employed
as virtual memory and, I suspect, for hibernation and hybrid suspension.

About file systems: I typically use FAT32, NTFS, ext4, and ext2. (Total newbie.)
FAT32 is elderly and fragile. It's used for boot/EFI partitions, 3DS & 3GPs.
NTFS is Microsoft's modern FS. Withstands some crashes, but has no fsck module.
ext2 & ext4 are Linux's. ext4 journals. ext2 permits file undeletion (PhotoRec).
The extended 4 system is harder to kill than a cockroach on steroids, so I tend
to prefer it anywhere near the heart of my archives. I use ext2 | NTFS for USBs.

Be very careful not to destroy your existing data when repartitioning the drive.
Any such operation carries some risk; back up anything important beforehand. One
way to backup is to prepare an empty HDD (or any medium of equal / greater size)
and dump the complete contents of the populated disk into the empty one:
 dd if=/dev/sda of=/dev/sdb status=progress
 (Where sda is the populated disk, and sdb the empty backup disk.)
Similar can be accomplished by dd'ing one of your partitions (/dev/sda1) into a
disk or a file, then dd'ing the image back onto a partition of equal size. Disk
image flashing is a simple and popular backup method for local machines, sparing
you the time to learn rsync (which is more useful in long term remote backups).
Far from being an annoying elder sister, dd is the Linux troll's best friend.

Beware the dreaded "write a new boot/system partition" prompt. It bricked me.
The problem was because I had set the system to "Legacy Support" boot mode, but
the original (now unrecognized) installation was in Extended Firmware Interface
mode. I was unable to recover until I had re-flashed several partitions.

The usual "new car smell" applies: you'll want to configure whatever settings
haven't yet been forbidden to you by your GUI-toting overlords. In Ubuntu 16,
access them by clicking the gear and wrench icon on the launcher panel. You can
also search for something you're missing by using the Dash (Super, or Windows,
key pulls it up: then type), which functions similarly to the apropos command:
e.g., instead of Ctrl + Alt + T and then "man -k image", Super key then "image".
It will also search your files (and, after plugins, several social media sites).

Although the newfangled Dash is convenient, don't forget your terminal emulator:
you can easily spend the vast majority of your working time using bash by way of
gnome-terminal, without ever clicking your treasured Microsoft IntelliMouse 1.1.
In Ubuntu 16, as it has been since Ubuntu 11, Ctrl + Alt + T opens the terminal.

Under the directory /usr/share/man/, you will find the on line (interactive)
manual. This describes the tools available to you. Begin reading it by opening
a terminal window (using Control + Alt + T, or the Super / Windows key and then
typing "terminal"), keying the command 'man name_of_manual_page', and pressing
the Enter key. In this case, the name of the manual page is the page's archive's
filename before the .[0-9].gz extension.
Of particular interest: telinit, dd, printf, cat, less, sed, tee, gvfs-trash,
mawk, grep, bash (if you're using the Bourne Again Shell, which is default on
Ubuntu 16), cp, rm, mv, make, sudo, chroot, chown, chmod, chgrp, touch, gunzip,
gzip, zip, unzip, python, g++, apt-get (especially `apt-get source ...`), mount,
kpartx, date, diff, charmap (same name on Windows!), basename, zipinfo, md5sum,
pdftotext, gnome-terminal (which is _how_ you're using bash), fortune, ffmpeg,
aview, dblatex, find, cut, uniq, wc, caesar, rot13, curl, wget, sort, vim, man,
tr, du, nautilus, tac, column, head, tail, stat, ls, pwd, pushd, popd, gedit,
source-highlight, libreoffice (a Microsoft Office killer), base64, flex, bison,
regex, perl, firefox, opera, chromium-browser, konqueror, lynx, virtualbox,
apropos, od, hexdump, bless, more, pg, pr, echo, rmdir, mkdir, fsck, fdisk (same
name, but different function, in Windows), ln, gdm, gnome-session, dhelp,
baobab, gparted, kill, locate, ps, photorec, testdisk, update-grub...
(If you haven't some of the above, don't worry. You should already have all you
 need. Keep in mind that the Ubuntu repository's software is divided in sections
 some of which contain potentially harmful or non-free software. When venturing
 beyond the fortified walls of <main>, be cautious: you may be eaten by a grue.)
Beneath /usr/share/doc/ or /usr/share/help/ are sometimes additional manuals.

If you use Linux, you will have to memorize several manuals, and name many more;
especially those of the GNU core utilities, which are a great aid to computing.
There's also a software repository to assist you with various computing tasks:

To acquire additional software: gnome-software (the orange shopping bag to your
left, above the Amazon.com icon), the friendly storefront, will assist you. If
you prefer a compact heads-up-display, try the Synaptic Package Manager instead.
`apt-get install package-name` works well if you know what you're looking for,
as does apt-get source package-name for the ponderously masculine.

And, speaking of ponderous masculinity, if you retrieve source code for any of
Ubuntu's mainline packages, typically all you need to do is 'cd' into the folder
containing the top level of the source tree and then invoke the following:
 1. ./configure.sh
 (You shouldn't need to chmod u+x ./configure.sh to accomplish this.)
 2. make
 (You may need to install additional packages or correct minor errors.)
 3. sudo make install
This can be abbreviated: ./configure.sh && make && sudo make install
Beware that sudo is a potentially dangerous operation. Avoid it if unsure.
The && operator, in bash, will only execute the next command if the past command
exited with a successful status code (i.e., zero).

But I digress.

You'll occasionally want to mount your other partitions on Linux's file system,
so that you can browse the files you've stored there. With external drives this
is as simple as connecting them (watch the output of `tail -f /var/log/*` in a
console window to observe the log messages about the procedure), but partitions
on fixed disks (or others, 'cause reasons) may not be mounted automagically. So:
 mount -t fs_type -o option,option,... /dev/sd?? path/to/mount/point/
where the mount point is a directory somewhere in your file system. BTW, mounts
that occurred automatically will be on points beneath /media/your_username/.

On a dual boot Windows system, I mount -t ntfs -o ro /dev/sda3 ~/Desktop/wintmp
often because the NTFS partition is in an unsafe state and won't mount writable.
In that case, rebooting to Windows and running chkdsk /f C: from Command Prompt
with Administrative privileges will sometimes clear the dirty flag if performed
multiple times. (How many times before ntfs-3g mounts writable, seems to vary.)

When you've attached external media, via USB etc, safely remove them after use:
use the "Safely Remove" menu option in the right-click context menu in Nautilus'
sidebar (be careful not to accidentally format the disk). You can also, from a
shell (gnome-terminal), `sync && umount /dev/sdb*` (if sdb is the medium).

Now that you've got a firm foothold in Ubuntu territory, I hope you can see your
house from here 'cause Windows seems to be dying a miserable death of attrition.
Don't count it out, though: all the Linuxes are terrible at Flight Simulator.
Dash Maid, by Alason.

Booty Is In The Eye Of The Beholder.

(NB: at time of writing, Vide is still its Alpha testing phase.
     If you're only here for Vide, try again at 1q-2q 2018.)

Welcome yet again, intrepid reader, to the idyllic pastures of Moon Yu.
(^- Allusion to _Kung Pow: Enter the Fist._)

I've been having trouble coding anything extraordinary; so, for this edition,
I've written briefings covering the broad strokes of three quotidian programs.
Thankfully, modern languages like Bash and Python make software design easy, so
some of this (what I might have called dross, in better days) may interest you.

None of these programs are anything new, I'm sorry to say. Although you may not
have seen or heard of them before, I assure you they're quite trite. Nonetheless
this one in particular approaches a popular problem in an excellent way. I think
the memetic teenage and otaku demographics will be most enthusiastic!
(Unless they have to make a new font for it. What a dull task that would be.)

It's called "Videlicet." That's from two Latin words, "videre" & "licet," which
mean "to see" and "it is lawful; permitted; easy," thus "it can be seen." This
word "videlicet," abbreviated "viz," is used in the law: indicating the party is
not required to prove what he alleges (possibly because of a preceding verdict).
Here I mean simply "it's easy to see": a reference to its informational overlay.

My goal in writing Videlicet was to craft a programmatic means to attribution.
Because I often download many drawings and macros, and later forget where they
came from, the time was way past ripe to prepare somesuch "labeling machine." If
you're like me, you have Gigabytes of poorly-attributed drawings found at social
networks -- every one, inexplicably, without even the artist's signature! -- and
I'll bet you wish you had recorded as well as possible the provenance of each.

Perhaps with some program that automatically records this information for you?

Videlicet is such a script: a combination harvester for static-markup galleries.
I grant it to the Public Domain too, insofar as the source code _is_ mine.
Obviously, Python's libraries (and Python itself) belong to others: so, if you
intend commerce, consult its authors. (I think the language has copyrights.)

As usual, to download it, retrieve my portfolio from the links to MediaFire that
are supplied in the top post at my WordPress blog: https://ipduck.wordpress.com.

Two salient paradigms to be seen in Videlicet are typeface-rendering & grepping.
These are the major parts required to write stuff & to figure out what to write.
Shell scriveners worldwide have surely accomplished similar with their own tools
-- at a minimum, invoking wget to mirror the Web gallery containing the drawing
will do the same -- or simply written by hand in bibliographical text files, but
here I've described a program to inscribe that information _on_ the pictures.

First of all: how to make writing a thing? The Python Imaging Library (PIL) has
facilities fain to furnish fonts, but I felt a fool for failing to fathom their
fructuous function. I resolved to write my own: a simplistic cut-and-paste font
engine that gets the job done economically but without panache.

The desired typeface is encoded, character by character, as images of any type.
These are then loaded into memory and overlaid upon a panel of solid color. The
resulting "text box" is its own image, which I then attach to the retrieved one.
A few amusing effects are made possible by way of PIL's transformations.

The portions of the script that encode the font and the deceptively simple state
automaton that acts as a "typewriter" actually required about a thousand lines
and weeks before I was entirely satisfied. I give them short shrift here because
the vast majority of it is the exceedingly banal "move the cursor, check that it
hasn't traveled out of bounds, then paste a glyph into the image" procedure.

More on that procedure can be found in CharSet(), Overlay(), and JuiceFusion().
Videlicet can write forward, backward, up and down, using any font you create.

Second: how do I know what to write? This is a task I usually accomplish using
grep (the General Regular Expression Parser) and sed (the Stream Editor) in a
command line in my bourgeois gnome-terminal. I'd first feed the page's source,
probably via curl (a URL catenator), into a grep invocation that finds for me
the lines with the information I need, then into a sed invocation that massages
them into whatever format I want them to look like in the finished result.

(Such procedure is so commonplace that "grep" in jest can be a pun on "grope.")

Here, a similar procedure is executed against a downloaded HTML file in memory.
The files are retrieved by way of Python's hypertext transport facilities. If I
read Py's manual correctly: cookies, authentication, and proxies are supported.
Regular expressions are then employed to sieve the text and harvest any metadata
relevant to the user's records. The data, proper, is then harvested as well.

Actually sieving through the text necessitated contrivance. You see: text (such
as documents written in Hypertext Markup Language) changes a lot these days,
especially at corporate boilerplate factories like social networks. Interfaces
can't be relied upon from a robotic perspective, because programmers must always
be prepared to update the robots, which defeats the bot's purpose: to save you
valuable time and thought. Every time I visit MyTwitFeedFaceTube+(TM), I either
write a new "curl | grep | sed | mawk | while read ...; do ...; done" sieve or
just throw my hands up and use a foolish human GUI-capable Web browser. And, of
course, I still can't figure out Windows' interprocess communication metaphor,
so I'm dead in the water there too.

"Ballocks," I grumbled in this regard of late Spring, and grudgingly resolved to
implement a portable framework for execution of the usual sieving tasks.
At some overextended length, Videlicet's target acquisition procedure was born.
By the configuration files' powers combined, and with reference to a few short
(thanks to Python's standard libraries) convenience functions that effect the
vast majority of everything I ever do with GNU/Linux, it is Captain Planet.

Uh, I mean: it is able to effect the same reformatting operations.

As for retrieval of the text to be sieved and reformatted:

Videlicet simply employs the Python interpreter's capability of arbitrary code
execution via eval(), exec() and friends. In this fashion it constructs classes
that encode a recursion chain. Progressing from the initial phase of target
acquisition, through each step of winnowing the HTML (or Javascript, or whatever
-- although Videlicet doesn't implement a formal parser such as Bison or PLY and
is therefore devoid of any capacity to disassemble and recompile active code, it
can still effect a certain degree of penetration if the URL can be guessed) to
locate embedded Uniform Resource Locators within tags & stylesheets, and finally
to conclusory retrieval of the desired image & overlaying the historical record.

Once resources are harvested the discerning archivist has at his or her disposal
a wealth of pertinent data gathered automatically during Videlicet's operation.

Not only is the rendered image, with added informational overlay, saved to disk;
a copy of the original is also saved, as is a text file containing a record of
the transaction's HTTP headers (and, optionally, additional metadata). Actually,
the latter two records are saved for all fetched resources, just in case you
needed them. Naturally, this additional time stamping & record keeping clutters
up the burgh, so Videlicet is a lot less convenient to use than wget or curl.

Speaking of inconvenience, I ought to mention another one of its major caveats:
due to the manner of data retrieval, some of the target's original metadata
(including its times of last access, modification, status change, and birth,
which are remarkably important from a historical perspective) is irreparably
lost unless included with the HTTP headers. I could solve this problem by
reference to any Web browser's code to see how they preserve the information,
but after writing all the rest of it I was in a hurry to take some time off.

And, of course, the final indignity: because Vide requires the Python Imaging
Library, and I have no idea how to cross-compile this for Windows, you'll be out
of luck if you want to use it and can't find an installation with PIL available.
(_And_ I don't know where you can find one!) I am most sincerely regretful about
this fact, because Vide is one hell of a finite state automaton.

Given all that fuss and bother, why have I gone to the trouble of writing Vide?
Because I am sick and tired of downloading images from social networks only to
lose all the information recorded in the original post, even if there _is_ none.
A means to stamp images acquired from disparate sources was clearly necessary.

There are some other interesting bits in Videlicet. For example, it's scriptable
(employs arbitrary code execution via eval(), which is bad engineering practice
but saves me a little time), and can be employed to render text upon images you
already have. Regardless, all the technical complexity is as illustrated: the
remainder of Videlicet is a set of simple wrappers around grabbing and labeling.

Videlicet is my first Python 3 program. Unless the Python language undergoes any
further dramatic revision, this script will live on in posterity. (Really. It's
a pretty big deal.) Otherwise, you might want to get your kicks out of it now.
I don't plan to maintain it because, even if the language changes, I'm tired.

Cheroot Privileges: a Potpourri of Pointlessness.

Cheroot (Tamil "shuruttu" meaning "a roll"): a cigar. Reputed to be pungent.
chroot (GNU coreutils, manual section 8): run command in special root directory.
Potpourri: a compost heap, montage, medley, or ragout. NB: never compost meat.
Root privileges: to have these is to be the super-user, operator, admin, etc.
Root: a dental nerve, et c.

My foregoing post touched on socket programming, when I mentioned TFTP. (BTW, MS
Windows has a TFTP client built-in: in the Programs & Features control panel app
open "turn Windows features on or off.")

Sockets are a hardware abstraction layer that deals with computer networking.
As usual, gritty details are beyond me and I gloss them over. (Tee hee. That's a
pun about oyster pearls.) Suffice to say that sockets are ports of call for data
transmitted between computers: hardware and protocol not withstanding, bytes fly
out one socket and land in another. We built this Internet on socket calls.
(A pun on Jefferson {Airplane,Starship}'s "We Built This City.")

For more information, consult the RFCs, and the IEEE's 802.* network specs.
Perhaps ftp.rfc-editor.org, www.faqs.org/rfcs, or www.ietf.org/rfc are of use?

And an update to my Javascript snippet in the remedial lecture...
    function initnary (ctr) { for (var i=0; i < ctr.length; ctr[i++] = 0); }
    function incnary (counter) { // Faster, but rollover instead of sentry.
        for (var L = counter.length, i = L - 1;
             (nary[i] = ((nary[i--] + 1) % L)) == 0 && i > -1;
        ) ; // Faster than the example in WP12, but rollover not sentry.
    } // end incnary(): Increments N-ary counter (length >= 1), by reference
    // ...
    var nary = new Array(items.length);
    initnary(nary); // nary's state: 0 0 0 ... 0
    incnary(nary); // nary's state: 0 0 0 ... 1
    // ...
... which is possibly a bit faster than the other one, although neither will be
optimized by an optimizing compiler (due to the complicated loop initializer), &
therefore both are of marginal utility.

It's 2017. To begin my new year on the right foot, I began it on the wrong foot.

My first hint that I'd need to effect some impromptu renovations to my skeleton
came to me when I noticed that I had begun to experience an unpleasant taste of
musty dust after picking clean my right anterior maxillar tricuspid. (The reason
why shattered teeth taste of moist chalk is probably because dentine & chalk are
both calcareous substances. I'd guess chalk rots too, if infected.) Another way
I could describe the taste of a rotten tooth is "like hard-boiled eggs that were
rotten before they were boiled," because they smell and taste alike. The dentine
(the material composing the interior of teeth) also feels distinctly like chalk,
or like gritty soil, when I palpate it with my tongue.

Anyway, my left anterior mandibular tricuspid has also been a goner since auld
lang syne, and the bone fragments left over inside my gums have really begun to
bug me, so a taste of fetor was the last straw.

Luckily, I had a small piece of surgical gauze left over from when I foolishly
had my wisdom teeth removed. (If you're considering removal of yours, then I am
here to tell you: DON'T! It's a waste of money, and, unless your teeth are truly
rotten or a source of pain, there is simply _no reason_ to remove even one.) If
you haven't tried to get a grip on one of your teeth before, you wouldn't know,
but even a tooth you've wiped dry is difficult to grasp without gauze.

I'm also the lucky owner of a pair of surgical forceps. These handy little tools
look like a long and delicate pair of pliers with the fulcrum very close to the
gripping side of the levers. ("They really pinch.")

In case you were curious, forceps are usually employed to grasp small objects in
surgical procedures. They can also be used as roach clips. (For avoiding burns &
stains of the fingers while smoking. Wide pipe stems containing packed cotton
accomplish the same end: you can make one from a hollow ballpoint pen and cotton
balls sold at any general store. Nevertheless a forcep is more generally utile.)

Those teeth's days had long been numbered. Their time had come!

So it was that I spent tedious hours doubled over with my fingers crammed in my
mouth, wiggling that thrice-damned curse of a bone to try and work it loose.
I quite unwisely, and disregarding the risk of breaking my jaw, channeled thirty
years of pent aggression into what remained of my tricuspid molar, as malodorous
flakes of rotten enamel & dentine fell upon my tongue like evil snow.

I knew I had effected some kind of progress when I heard a muffled click inside
of my head -- bones have eerie acoustic properties, like an unsettling resonance
and a tendency to produce a crunching sound (rather than a snap) when fractured
-- and felt a stabbing pain travel up the side of my head. Thankfully the pain I
felt due to prolonged migraine headache rendered this somewhat less intolerable.

I repeated this procedure until I lost consciousness.
Well, that's how I had hoped that this would end, but it didn't.
I could not bear the pain, and had to stop trying to pull my tooth.

Unfortunately for me, although I did manage to work the molar somewhat further
out of my jaw than it had loosened already (my dental hygiene, in case the memo
hasn't reached you, is worse than Austin Powers'), I didn't completely extract.
All I managed to do was cause a hairline fracture of my maxilla, which will un-
doubtedly be a source of major difficulty and pain to me in the decades to come.

Worse yet, my application of too much pressure via the forceps caused additional
shattering of the tooth; further attempts at extrication are counterindicated.
That's just as well, because the kind of general-purpose forceps I had available
aren't for dental extraction: this requires a special kind of forcep I hadn't.

I suppose it's just as well: considering the fact that some dentine remained in
the shell of the tooth, its nerve was probably still alive and well. The nerves
connecting teeth to the root canal are extremely sensitive, and interconnected;
what's worse, I could easily have broken my jaw by violently levering the tooth;
therefore, extracting my tooth myself would very likely have been suicide.

So, as far as sockets go, my teeth will be rotting in theirs for some time yet.

Other noteworthy pratfalls during January:
1. Accidentally locked myself out of Windows by attempting to install Ubuntu 16
   alongside, which occurred after it prompted me to designate a BIOS boot part
   (prior installs didn't manifest the prompt and gave me no trouble).
2. Locked myself out of Ubuntu too by trying to unbrick Windows.
3. Flashed in the backup EFI system partition and boot sector from a disk image,
   reset the partition table with fdisk, thanked lucky stars, began again at 1.
4. Broke shiny new laptop's fragile keyboard connector. Cursed fate.

Incidentally, I had some luck using this procedure to regain access to a Lenovo
IdeaPad 100-151BD 80QQ's UEFI Firmware Configurator after I had set my boot mode
to Legacy Support before installing Ubuntu, which locked me out of the config:
    1. At GRUB operating system selection screen key 'c' for a command line.
    2. normal_exit
    3. initrd
    (initrd fails because you didn't load the kernel, but then Windows Boot
     Manager tries to load in UEFI mode for some reason & presents a screen
     politely offering to give you the FW Config if you give it the ESC key,
     which it doesn't usually when your boot mode is Legacy Support instead
     of UEFI with or without secure boot.)
I ought note: Ubuntu 16 boots the configurator automagically in UEFI boot mode:
the option reappeared when I `sudo update-grub`ed while in UEFI mode.

Speaking of GRUB, here's a boot procedure (in case you've never driven stick):
    1. root=hd0,gpt8
       (Linux is at sda8 on my system)
    2. linux /vmlinuz
    3. initrd /initrd.img
    4. boot
Or, to shift gears into Windows:
    1. root=hd0,gpt1
    2. chainloader /EFI/Microsoft/Boot/bootmgfw.efi
    3. boot

While I'm on the topic, here's how to play a tune at boot time using GRUB:
    A.1. @ boot menu (operating system selection), key 'c' for a GRUB shell.
    A.2. play TEMPO PITCH1 DURATION1 PITCH2 DURATION2 P3 D3 ... ad infinitum
         Pitches are frequencies in Hertz; duration is a fraction of tempo.
    B.1. In Ubuntu, Control + Alt + T to open a terminal emulator window.
    B.2. sudo gedit /etc/default/grub
    B.3. Feed the recordable piano by editing the line at the bottom:
         GRUB_INIT_TUNE="325 900 6 1000 1 900 2 800 2 750 2 800 1 900 2 600
5 0 1 500 1 600 1 800 1 750 2 600 2 675 2 750 4"
         # ^- The Amazing Water (NiGHTS)
         GRUB_INIT_TUNE="1024 600 2 650 2 700 2 950 10 900 20 0 10 600 2 650
2 700 2 950 20 1050 10 1100 5"
         # ^- Batman, the Animated Series.
         GRUB_INIT_TUNE="2048 600 5 0 1 600 5 0 1 575 5 0 1 575 5 0 1 550 5
0 1 550 5 0 1 575 5 0 1 575 5 0 1 600 5 0 1 600 5 0 1 575 5 0 1 575 5 0 1
550 5 0 1 550 5 0 1 575 5 0 1 575 5 0 1 900 8 0 4 900 24"
         # ^- classic Batman.
    B.4. Save the file, and then sudo update-grub && sudo reboot
Musical notes within the 500-1500 Hz range tend to be within 100Hz of each other
(therefore ± 50 Hz for flats & sharps) typically, but act strange around 600 Hz.

GNU/Linux is dandy for computer programming, especially data processing, because
it is now (thanks to Ubuntu) easier to use than ever; but it changes so quickly
that I've barely skimmed over the repository before the next long-term support
version has been finalized. The installer wizard also sometimes makes mistakes.
The software repository is slowly morphing into a dime-store, any software worth
using requires considerable technical expertise cultivated @ your great expense,
and if anything breaks then you have to be the fastest teletype gun in the west.

And, because my comments re: Linux may mislead, I'm thrilled about Windows 10.
Have you played Microsoft Flight Simulator recently? Great game.