April 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 2019

Page Summary

Expand Cut Tags

No cut tags
mdlbear: (technonerdmonster)

In my previous curmudgeon post, Writing Without Distractions, I gave version control only a brief mention, and promised a follow-up post. That would be this one. This post is intended for people who are not in the software industry, including not only poets but other writers, students, people who program as a hobby, and programmers who have been in suspended animation for the last decade or three and are just now waking up.

The Wikipedia article on version control gives a pretty good overview, but it suffers from being way too general, and at the same time too focused on software development. This post is aimed at poets and other writers, and will be using the most popular version control system, git. (That Wikipedia article shares many of the same flaws as the one on version control.) My earlier post, Git: The other blockchain, was aimed at software developers and blockchain enthusiasts.

What is version control and why should I use it?

A version control system, also called a software configuration management (SCM) system, is a system for keeping track of changes in a collection of files. (The two terms have slightly different connotations and are used in different contexts, but it's like "writer" and "author" -- a distinction without much of a difference. For what it's worth, git's official website is git-scm.com/, but the first line of text on the site says that "Git is a free and open source distributed version control system". Then in the next paragraph they use the initialism SCM when they want to shorten it. Maybe it's easier to type? Go figure.)

So what does the ability to "track changes" really get you?

Quite a lot, actually! )

...and Finally

The part you've been waiting for -- the end. This post is already long, so I'll just refer you to the resources for now. Expect another installment, though, and please feel free to suggest future topics.

Resources

Tutorials

Digging Deeper

Another fine post from The Computer Curmudgeon (also at computer-curmudgeon.com).
Donation buttons in profile.

mdlbear: (technonerdmonster)

A few years ago I read an article about how to set up a Mac for distraction-free writing. I can't seem to find it anymore (okay, some rather large value of "a few"), but "there's an app for that" now. Many writers on my reading list are talking about distraction-free writing tools like iA Writer (seems to be the one people are most impressed by at the moment) and FocusWriter (free and cross-platform). There's even an Emacs mode.

These all work roughly the same way: run a text editor in full-screen mode, and write plain text with simplified markup in a fixed-width font. Worry about formatting later, if at all. Grey out everything but the sentence or paragraph you're working on. The article I can't find -- written before specialized writing programs and even before the web -- suggested getting the same effect by taking all of the icons off your screen and setting your default font to Courier.

If you're happily using one of these tools, you may want to skip ahead to the section on formatting, and maybe fill in the gaps later. If you're still using a word processor, or typing into a text field in a browser (even in "rich text" mode), you should probably stick with me.

What You See is All You Can Get

WYSIWYG (What You See Is What You Get) word processors are arguably the worst thing to have happened to writing in the last half-century. They have three huge problems:

The first is that they make a promise they can't deliver on. In fact, they should be called WYSIAYCG -- What You See Is All You Can Get. If your word processor doesn't support kerning, multiple fonts, paragraphs with hanging indents large initial capitals, mathematical notation, or internal cross-linking, you can't use them. If they make it difficult to use these features, you still won't use them unless you absolutely have to, and then you find yourself wasting time doing clumsy work-arounds. Think about how you'd go about formatting song lyrics with chords over them. Shudder. How about making the space between sentences equal to one-and-a-half times the space between words?

The second is related to the first: word processors target a specific page layout. If you want to make a printed book, a web page, and an eBook, you're going to have to do extra work to accommodate the differences, or settle for something that has about the same level of mediocrity in all of those environments.

At a lower level, word processors use proportional-spaced fonts. That means you have to peer over the tops of your glasses to see whether that character at the end of the sentence is a period or a comma, and if your hands are shaking from too much coffee you'll have trouble selecting it. Or putting the cursor in front of it without selecting it, if you want to add a few words.

The third is that they distract you from actually writing, tempting you to fiddle with fonts, reformat your footers, worry about word-wrapping and hyphenation, and place your page breaks to avoid widows and orphans, at a time when you should be concentrating on content.

There's a fourth, mostly unrelated, problem which is so pervasive these days that most people accept it as The Way Things Are: if you accidentally select something and then type, whatever you selected goes away. In almost all cases, even if your word processing has an "undo" feature, this can't be undone. So let's talk a little more about...

Editing

Anyone who's been hanging around me long enough is expecting me to mention GNU Emacs at some point, and I will. But there are plenty of other text editors, and most of them are perfectly usable. They're often called "programmers' editors".

I'm not going to tell you how to use a text editor here; I'm just going to tell you more about why, and point you at some resources. Michael Hartl's Learn Enough Text Editor to Be Dangerous is a pretty good introduction to most of them, though you may want to skip the chapter on Vim. It gives short shrift to Emacs, but fortunately the first thing on your screen after starting Emacs is the tutorial. Start there.

So, why would you, a writer, want to use a programmer's editor?

One reason is that programmers have been writing on computers for a quite a bit longer than writers have, so text editors have a considerable head start. More to the point, programmers use their own programs. This gives them a strong incentive to make their programs fast, efficient, and powerful. Not every programmer who has a problem with their text editor is going to fix it, but enough do to make them improve rapidly.

Word processors, on the other hand, are written by programmers, but they are usually written for ordinary users, not experts, and they're written to be products, not programming tools. As products, they have to appeal to their customers, which means that they have to be easy to learn and easy to use. They don't have to work well for people who spend their entire work day writing -- those are a tiny fraction of the customer base.

Another reason is that text editors use fixed-width fonts and encourage you to use comparatively short lines (typically 72 or 80 characters, for reasons that date back to the late 1880s). Paragraphs are separated by blank lines. Since line breaks inside of paragraphs are ignored by formatters, some authors like to start every sentence on a new line, which makes them particularly easy to move around, and makes it easier to spot differences between versions.

A text editor also makes you more efficient by giving you a wide range of keyboard commands -- you can write an entire book without ever taking your fingers off the keyboard. (This is, in part, due to their long history -- text editors predate graphical user interfaces by several decades.) And most modern text editors are extensible, so that if you want new commands or want them to behave differently for different kinds of markup, they're easy to add. (I have a set that I use for my band's lead sheets, for example, and another for my to-do files.)

Markup

Up until somewhere around 1990, everyone who did any serious writing knew how to edit a manuscript using proofreaders' marks. Manuscripts were typed double-spaced to leave room for insertions, corrections, and cryptic little marks between the lines and in the margins. This was, logically enough, called "marking up" the manuscript. You've probably heard of Markdown. You've certainly heard of HTML, which stands for "HyperText Markup Language". HTML, in turn, is a variant on SGML, "Standard General Markup Language". You may have heard of LaTeX, which is the standard for academic -- especially scientific -- writing.

Markup languages let you separate content writing from formatting. Semantic markup lets you add additional information about what the things you are marking up mean; it's up to a stylesheet to determine what they look like . In HTML, you don't have to <i>italicize</i> something, you can <em>emphasize</em> a talking point, or <cite>cite</cite> a book title. They usually look the same, so most people don't bother, until they decide to turn all the book titles in their two thousand blog posts into links.

You can see how using semantic markup can free you from having to think about formatting while you're writing. There's another, less obvious advantage: you aren't stuck with just one format. By applying different styles to your document you can make it a web page, a printed book, an eBook, a slide show, or an email.

Another advantage of markup languages is that all of the markup is visible. This week's xkcd: "Invisible Formatting", shows how you can accidentally make a boldface space in the middle of normal text, where it can distract you by making an insertion unexpecedly boldface. It may also make subtle changes in line and word spacing that are hard to track down down.

There are two main kinds of markup languages: ones like Markdown and Textile, that use simple conventions like **double asterisks** for strong emphasis, and the ones that use tags, like <cite>HTML</cite>. LaTeX and Restructured Text are somewhere in the middle, using both methods. You can be a lot more specific with HTML, but Markdown is far easier to type. Markdown and Textile let you mix in HTML for semantic tagging; Markdown, Textile, and Resturectured Text all use LaTeX for mathematical notation. Some formatters let you embed code with colored syntax highlighting.

These days, it looks as though Markdown is the most popular, in part thanks to GitHub; you can find it in static site generators like Hugo and Jekyll, and it's accepted by many blogging platforms (including Dreamwidth). Unfortunately they all accept different dialects of Markdown; there is an enormous number of Markdown-to-whatever converters. But the nice thing about markup languages is that you aren't stuck with just one. That brings us to...

Formatting

Once you have a file that says exactly what you want to say, the next thing you'll want to do is format it. Formatting programs (a category that includes LaTeX, web browsers, website generators like Jekyll and Hugo) all use some kind of style sheet that describes what each kind of markup is supposed to look like. You probably know about CSS, the "Cascading Style Sheets" that are used on the web. LaTeX has a different set, written in the typesetting language TeX.

If you wrote your file in HTML and you want to publish it on the web, you're done. You may want to make your own stylesheet or customize one of the thousands that are already out there, but you don't have to. Modern browsers do a perfectly reasonable job of formatting. CSS lets you specify a separate style for print, so when a reader wants a printed copy it actually looks like something you'd want to read on paper.

If you wrote your file in LaTeX and you want to publish it on paper, you're done -- it's safe to assume that LaTeX knows more about formatting and typesetting than you do, so you can just tell LaTeX what size your pages, pick one of the hundreds of available stylesheets (or write your own), and let it make you a PDF. You can change the page size or layout with just a few keystrokes.

If you wrote your file in Markdown or some other markup language, there are dozens of formatting programs that produces HTML, LaTeX, PDF, or some combination of those. (My favorite is Pandoc -- see below.) Markdown is also used by static website generators like Hugo or Jekyll, and accepted by everything from blogging sites to GitHub. If you're publishing on the web or in some other medium your formatter supports, you're done.

The advantage of separating content from format is that you're not stuck with one format. Web? Print? eBook? You don't have to pick one, you have all of them at your fingertips. There are hundreds of conversion programs around: html2latex, latex2html, kramdown (which GitHub uses),... For most purposes I recommend Pandoc. The subtitle of Pandoc's home page calls it "a universal document converter", and it is. It can convert between any of the the markup languages I've mentioned here, and more, in either direction. In addition it can output eBook, word processor, wiki, and documentation formats, not to mention PDF. As an example of what it can do, I write these posts in either HTML or Markdown as the mood takes me, and use Pandoc to convert them to HTML for Dreamwidth and plain text, stripping out the tags, so that I can get accurate word counts.

Version Control, etc.

Text files with short lines are ideal for other tools in the Linux (and Unix -- did you know that Unix was originally used by technical writers?) environment. When you compare two files, a line-by-line comparison (which is what diff gives you) is more useful than a paragraph-by-paragraph comparison (which is what diff gives you if you don't hard-wrap your text). Text editors can run formatters, spelling checkers, search tools, and others, and put the cursor on the exact line you're looking for. Want to search nearly 6500 blog posts for your favorite quote from G. K. Chesterton? Took me one line and a little over 4 seconds.

        time find . -type f -exec grep -nHi -e 'rules of architecture' {} +

Many formatting tools simply ignore single line breaks and use a blank line to separate paragraphs, examples include LaTeX and most (though not all) Markdown translators. HTML ignores line breaks altogether and relies on tags. I take advantage of that to make HTML more readable by indenting the text by four spaces, and using 80- or 90-character lines. If you want an example and you're reading this page in a browser, just hit Ctrl-U to look at the page source. Compare that to web pages made without hard-wrapped lines -- you may find yourself scrolling dozens, if not hundreds, of characters to the right because browsers don't do any wrapping when displaying source. Nor would you want them to.

The biggest advantage (in my not-so-humble opinion) is version control. (Those of you who've been around me were just waiting for me to mention git, weren't you?) Being able to find all the changes you made this week -- and why you made them -- can be incredibly useful. Being able to retrieve a file from three years ago that you accidentally deleted is priceless.

This post is already pretty long, so the next post in this series is going to be about version control (and the other things you can do with git and GitHub; it's not just version control) for writers. Stay tuned.

Resources

Another fine post from The Computer Curmudgeon (also at computer-curmudgeon.com).

mdlbear: (technonerdmonster)

It's getting so that data breaches aren't news anymore unless they're huge. The Gizmodo article calls it The Mother of All Breaches, exposing 773 million email addresses and 21 million passwords. There's a more complete post by Troy Hunt: The 773 Million Record "Collection #1" Data Breach. Hunt is the person behind the Have I Been Pwned website. That should be your next stop -- it lets you check to see which of your email addresses, usernames, and passwords have appeared in any data breach.

If your password shows up in Pwned Passwords, stop using it. Consider enabling two-factor authentication where you can, and getting a password vault. Hunt recommends 1Password. If you want open source, you can try KeePassX.

Another fine post from The Computer Curmudgeon (also at computer-curmudgeon.com).

mdlbear: (technonerdmonster)

Some day I ought to put together a comprehensive list of privacy-related links. This is not that list; it's just a few of the links that came my way recently, in no particular order.

I'd suggest starting with the ACLU's What Individuals Should Do Now That Congress Has Obliterated the FCC’s Privacy Protections. It's a good overview.

DuckDuckGo is my current privacy-preserving search engine of choice. The DuckDuckGo Blog has been a good source of additional information. I especially recommend this article on How to Set Up Your Devices for Privacy Protection -- it has advice for iOS, Android, Mac, Windows 10 and 7, and Linux. Also check out a broader range of tips here.

The Electronic Frontier Foundation, as you might expect, is another great source of information. I suggest starting with Tools from EFF's Tech Team. While you're there, install Privacy Badger. It's not exactly an ad blocker; what it does is block trackers.

Here's an article on Which Browser Is Better for Privacy? (Spoiler: it's Firefox.) Then go to Firefox Privacy - The Complete How-To Guide.

For the paranoid among us, there are few things better than Tor Browser. If you use it, you'll probably want to turn off Javascript as well.

The Linux Journal's article on Data Privacy: Why It Matters and How to Protect Yourself has a lot of good advice, most of which isn't Linux-specific at all.

However, if you are running Linux, you'll want to look at How To Encrypt Your Home Folder After Ubuntu Installation, Locking down and securing SSH access to your server, and Own Your DNS Data.

Another fine post from The Computer Curmudgeon (also at computer-curmudgeon.com).

mdlbear: (ccs)

In 1985 I wrote a song called: "The World Inside the Crystal". At the time there didn't seem to be any songs about computers, or programming, that weren't meant to be funny. (I think there might have been a few about AI or robots that were meant to be scary. It's entirely possible that this was the first serious computer song ever written.)

I also wanted to explore the notion that inside of computers is an alternate universe where magic works. I don't remember whether I came up with that, or somebody else mentioned it to me; it was definitely an idea that I was kicking around at that time. Kick it far enough, and it winds up someplace like this:

Beside the world we live in Apart from day and night Is a world ablaze with wonder Of magic and delight Like a magic crystal mirror, My computer lets me know Of the other world within it Where my body cannot go. chorus: You can only see the shadows Of electrons on a screen From the world inside the crystal That no human eye has seen. The computer is a gateway To a world where magic rules Where the only law is logic Webs of words the only tools Where we play with words and symbols And creation is the game For our symbols have the power To become the things they name. chorus Now you who do not know this world Its dangers or its joys You take the things we build there And you use them as your toys. You trust them with your fortunes, Or let them guard your lives. From the chaos of creation Just their final form survives. chorus Call us hackers, call us wizards, With derision or respect, Still our souls are marked by something That your labels can't affect. Though our words are touched by strangeness There is little we can say. You would only hear the echo Of a music far away. chorus

I can always tell the programmers in the audience -- they've been there. It won a Pegasus Award for "Best Science Song" in 1997, possibly because I mentioned it on Usenet.

There are several different recordings. The one to start with is Kathy Mar's cover here, off of her tape Plus &csedilla;a Change, with an awesome synth track by Chrys Thorsen. The one on my CD is okay, although I'm not all that happy with it now. It's way too fast, for one thing, and there isn't an instrumental break before the last verse. It's on YouTube courtesy of my distributor, CD Baby.

There have been some good ones in concerts. The one at Consonance 2009, with Tres Gique, is one of the better ones. Here's another, at Baycon 2009. Consonance 2012 appears to be my best (recorded) solo performance. Audio players don't come off all that well on DW, but I'll close with one anyway.

mdlbear: (technonerdmonster)

Most humans multitask rather badly -- studies have shown that when one tries to do two tasks at the same time, both tasks suffer. That's why many states outlaw using a cell phone while driving. Some people are much better than others at switching between tasks, especially similar tasks, and so give the appearance of multitasking. There is still a cost to switching context, though. The effect is much less if one of the tasks requires very little attention, knitting during a conversation, or sipping coffee while programming. (Although I have noticed that if I get deeply involved in a programming project my coffee tends to get cold.) It may surprise you to learn that computers have the same problem.

Your computer isn't really responding to your keystrokes and mouse clicks, playing a video from YouTube in one window while running a word processor in another, copying a song to a thumb drive, fetching pages from ten different web sites, and downloading the next Windows update, all at the same time. It's just faking it by switching between tasks really fast. (That's only partially true. We'll get to that part later, so if you already know about multi-core processors and GPUs, please be patient. Or skip ahead. Like a computer, my output devices can only type one character at a time.)

Back when computers weighed thousands of pounds, cost millions of dollars, and were about a million times slower than they are now, people started to notice that their expensive machines were idle a lot of the time -- they were waiting for things to happen in the "real world", and when the computer was reading in the next punched card it wasn't getting much else done. As computers got faster -- and cheaper -- the effect grew more and more noticable, until some people realized that they could make use of that idle time to get something else done. The first operating systems that did this were called "foreground/background" systems -- they used the time when the computer was waiting for I/O to switch to a background task that did something that did a lot of computation and not much I/O.

Once when I was in college I took advantage of the fact that the school's IBM 1620 was just sitting there most of the night to write a primitive foreground/background OS that consisted of just two instructions and a sign. The instructions dumped the computer's memory onto punched cards and then halted. The sign told whoever wanted to use the computer to flip a switch, wait for the dump to be punched out, and load it back in when they were done with whatever they were doing. I got a solid week of computation done. (It would take much less than a second on your laptop or even your phone, but we had neither laptop computers nor cell phones in 1968.)

By the end of the 1950s computers were getting fast enough, and had enough memory, that people could see where things were headed, and several people wrote papers describing how one could time-share a large, fast computer among several people to give them each the illusion that they had a (perhaps somewhat less powerful) computer all to themselves. The users would type programs on a teletype machine or some other glorified typewriter, and since it takes a long time for someone to type in a program or make a change to it, the computer had plenty of time to do actual work. The first such systems were demonstrated in 1961.

I'm going to skip over a lot of the history, including minicomputers, which were cheap enough that small colleges could afford them (Carleton got a PDP-8 the year after I graduated). Instead, I'll say a little about how timesharing actually works.

A computer's operating system is there to manage resources, and in a timesharing OS the goal is to manage them fairly, and switch contexts quickly enough for users to think that they're using the whole machine by themselves. There are three main resources to manage: time (on the CPU), space (memory), and attention (all those users typing at their keyboards).

There are two ways to manage attention: polling all of the attached devices to see which ones have work to do, and letting the devices interrupt whatever was going on. If only a small number of devices need attention, it's a lot more efficient to let them interrupt the processor, so that's how almost everything works these days.

When an interrupt comes in, the computer has to save whatever it was working on, do whatever work is required, and then put things back the way they were and get back to what it was doing before. This takes time. So does writing about it, so I'll just mention it briefly before getting back to the interesting stuff.

See what I did there? This is a lot like what I'm doing writing this post, occasionally switching tasks to eat lunch, go shopping, sleep, read other blogs, or pet the cat that suddenly sat on my keyboard demanding attention.

Let's look at time next. The computer can take advantage of the fact that many programs perform I/O to use the time when it's waiting for an I/O operation to finish to look around and see whether there's another program waiting to run. Another good time to switch is when an interrupt comes in -- the program's state already has to be saved to handle the interrupt. There's a bit of a problem with programs that don't do I/O -- these days they're usually mining bitcoin. So there's a clock that generates an interrupt every so often. In the early days that used to be 60 times per second (50 in Britain); a sixtieth of a second was sometimes called a "jiffy". That way of managing time is often called "time-slicing".

The other way of managing time is multiprocessing: using more than one computer at the same time. (Told you I'd get to that eventually.) The amount of circuitry you can put on a chip keeps increasing, but the amount of circuitry required to make a CPU (a computer's Central Processing Unit) stays pretty much the same. The natural thing to do is to add another CPU. That's the point at which CPUs on a chip started being called "cores"; multi-core chips started hitting the consumer market around the turn of the millennium.

There is a complication that comes in when you have more than one CPU, and that's keeping them from getting in one another's way. Think about what happens when you and your family are making a big Thanksgiving feast in your kitchen. Even if it's a pretty big kitchen and everyone's working on a different part of the counter, you're still occasionally going to have times when more than one person needs to use the sink or the stove or the fridge. When this happens, you have to take turns or risk stepping on one another's toes.

You might think that the simplest way to do that is to run a completely separate program on each core. That works until you have more programs than processors, and it happens sooner than you might think because many programs need to do more than one thing at a time. Your web browser, for example, starts a new process every time you open a tab. (I am not going to discuss the difference between programs, processes, and threads in this post. I'm also not going to discuss locking, synchronization, and scheduling. Maybe later.)

The other thing you can do is to start adding specialized processors for offloading the more compute-intensive tasks. For a long time that meant graphics -- a modern graphics card has more compute power than the computer it's attached to, because the more power you throw at making pretty pictures, the better they look. Realistic-looking images used to take hours to compute. In 1995 the first computer-animated feature film, Toy Story, was produced on a fleet of 117 Sun Microsystems computers running around the clock. They got about three minutes of movie per week.

Even a mediocre graphics card can generate better-quality images at 75 frames per second. It's downright scary. In fairness, most of that performance comes from specialization. Rather than being general-purpose computers, graphics cards mostly just do the computations required for simulating objects moving around in three dimensions.

The other big problem, in more ways than one, is space. Programs use memory, both for code and for data. In the early days of timesharing, if a program was ready to run that didn't fit in the memory available, some other program got "swapped out" onto disk. All of it. Of course, memory wasn't all that big at the time -- a megabyte was considered a lot of memory in those days -- but it still took a lot of time.

Eventually, however, someone hit on the idea of splitting memory up into equal-sized chunks called "pages". A program doesn't use all of its memory at once, and most operations tend to be pretty localized. So a program runs until it needs a page that isn't in memory. The operating system then finds some other page to evict -- usually one that hasn't been used for a while. The OS writes out the old page (if it has to; if it hasn't been modified and it's still around in swap space, you win), and schedules the I/O operation needed to read the new page in. And because that take a while, it goes off and runs some other program while it's waiting.

There's a complication, of course: you need to keep track of where each page is in what its program thinks of as a very simple sequence of consecutive memory locations. That means you need a "page table" or "memory map" to keep track of the correspondence between the pages scattered around the computer's real memory, and the simple virtual memory that the program thinks it has.

There's another complication: it's perfectly possible (and sometimes useful) for a program to allocate more virtual memory than the computer has space for in real memory. And it's even easier to have a collection of programs that, between them, take up more space than you have.

As long as each program only uses a few separate regions of its memory at a time, you can get away with it. The memory that a program needs at any given time is called its "working set", and with most programs it's pretty small and doesn't jump around too much. But not every program is this well-behaved, and sometimes even when they are there can be too many of them. At that point you're in trouble. Even if there is plenty of swap space, there isn't enough real memory for every program to get their whole working set swapped in. At that point the OS is frantically swapping pages in and out, and things slow down to a crawl. It's called "thrashing". You may have noticed this when you have too many browser tabs open.

The only things you can do when that happens are to kill some large programs (Firefox is my first target these days), or re-boot. (When you restart, even if your browser restores its session to the tabs you had open when you stopped it, you're not in trouble again because it only starts a new process when you look at a tab.)

And at this point, I'm going to stop because I think I've rambled far enough. Please let me know what you think of it. And let me know which parts I ought to expand on in later posts. Also, tell me if I need to cut-tag it.

Another fine post from The Computer Curmudgeon (also at computer-curmudgeon.com). If you found it interesting or useful, you might consider using one of the donation buttons on my profile page.

NaBloPoMo stats:
   8632 words in 13 posts this month (average 664/post)
   2035 words in 1 post today

mdlbear: (technonerdmonster)

Recently I started reading this Ruby on Rails Tutorial by Michael Hartl. It's pretty good; very hands-on, and doesn't assume that you know Ruby (that's a programming language; Rails is a web development framework). It does assume that you know enough about software development and web technology to be dangerous. And if you're not dangerous yet,...

It points you at a web site where you can learn enough to be dangerous. Starting from knowing nothing at all.

It's the author's contention that Tech is the new literacy [and] [l]earning the basics of programming is only one piece of the puzzle. LearnEnough to Be Dangerous teaches [you] to code as well as a much more powerful skill: technical sophistication. Part of that technical sophistication is knowing how to look things up or figure things out when you don't know them.

There are seven volumes in the series leading up to the Rails tutorial, giving you an introductory course in software development. I haven't gone to a bootcamp, but I'd guess that this is roughly the equivalent. More importantly, by the end of this series you'll be able to work through and understand just about any of the thousands of free tutorials on the web, and more importantly you'll have learned how to think and work like a software developer.

The first three tutorials lay the groundwork: Learn Enough Command Line..., Learn Enough Text Editor..., and Learn Enough Git to Be Dangerous. With just those, you'll know enough to set up a simple website -- and you do, on GitHub Pages. You'll also end up with a pretty good Linux or MacOS development environment (even if you're using Windows).

I have a few quibbles -- the text editor book doesn't mention Emacs, and the author is clearly a Mac user. (You don't need a tutorial on Emacs, because it has one built in -- along with a complete set of manuals. So you'll be able to try it on your own.)

The next three books are Learn Enough HTML to Be Dangerous, Learn Enough CSS & Layout, and Learn Enough JavaScript. The JavaScript is a real introduction to programming -- you'll also learn how to write tests, and of course you'll also know how to use version control, from the git tutorial.

At this point I have to admit that after starting the Ruby tutorial I went back and skimmed through the others; I'll probably want to take a closer look at the JavaScript tutorial to see if I've missed anything in my somewhat haphazard journey toward front-end web development.

The next book in the series is Learn Enough Ruby to Be Dangerouse. (If you skip it on your way to the Rails tutorial, there's a quick introduction there as well.) Ruby seems like a good choice for a second language, and learning a second programming language is important because it lets you see which ideas and structures are fundamental, and which aren't. (There's quite a lot of that about JavaScript -- it's poorly-designed in many ways, and some things about it are quite peculiar.)

Another good second or third programming language would be Python. If you'd like to go there next, or start from the beginning with Python, I can recommend Django Girls and their Tutorial. This is another from-the-ground-up introduction to web development, so of course there's a lot of overlap in the beginning.

Another fine post from The Computer Curmudgeon (also at computer-curmudgeon.com)

NaBloPoMo stats: 593 words in this post, 1172 words in 3 posts this month.

mdlbear: (technonerdmonster)

Actually two PSAs.

First: Especially if you're running Windows, you ought to go read The Untold Story of NotPetya, the Most Devastating Cyberattack in History | WIRED. It's the story of how a worldwide shipping company was taken out as collateral damage in the ongoing cyberwar between Russia and the Ukraine. Three takeaways:

  1. If you're running Windows, keep your patches up to date.
  2. If you're running a version of Windows that's no longer supported (which means that you can't keep it patched, by definition), either never under any circumstances connect that box to a network, or wipe it and install an OS that's supported.
  3. If at all possible, keep encrypted offline backups of anything really important. (I'm not doing that at the moment either. I need to fix that.) If you're not a corporation and not using cryptocurrency, cloud backups encrypted on the client side are probably good enough.

Second: I don't really expect that any of you out there are running an onion service. (If you had to click on that link to find out what it is, you're not.) But just in case you are, you need to read Public IP Addresses of Tor Sites Exposed via SSL Certificates, and make sure that the web server for your service is listening to 127.0.0.1 (localhost) and not 0.0.0.0 or *. That's the way the instructions (at the "onion service" link above) say to set it up, but some people are lazy. Or think they can get away with putting a public website on the same box. They can't.

If you're curious and baffled by the preceeding paragraph, Tor (The Onion Router) is a system for wrapping data packets on the internet in multiple layers of encryption and passing them through multiple intermediaries between you and whatever web site you're connecting with. This will protect both your identity and your information as long as you're careful! An onion service is a web server that's only reachable via Tor.

Onion services are part of what's sometimes called "the dark web".

Be safe! The network isn't the warm, fuzzy, safe space it was in the 20th Century.

Another public service announcement from The Computer Curmudgeon.

mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

It's been a week. There were some good parts. Music Under the Trees, yesterday at Betsy Tinney's, was one of them, even if we did have to leave early because Colleen was flagging. (I didn't object, because to be honest I'd been dreading driving home in the dark after three nights of not enough sleep. But still.)

Another was getting the rest of the bed box installation done, which happened last Sunday. It's awesome. N got to try it out Saturday night; it was complete enough for sleeping in at that point.

A third good thing wa a very nice visit to the southern end of the Rainbow Caravan, to spend a day with N and the kids. We will get our household back together. It may take a while.

And I got a very preliminary version of my "Consulting business" website done, as a GitHub Pages site. Last week N and I had picked a theme: Read Only, by HTML5 Up. It's cool - big banner across the top of the text, and a neat circular image (which it turned out was masked out by setting the enclosing box's boundary radius to 100%). Only one problem.

GitHub Pages are a snap to set up; you can do it in five minutes if you accept all the defaults. And it uses a nice static site builder called Jekyll which has themes that are pretty easy to set up. The devil's in the details, as usual. Because although we found "Read Only" through a gallery of Jekyll themes, it turned out that it wasn't a theme at all, just a mock-up. And although I eventually found a Jekyll version, it wasn't particularly usable.

I now know how to roll my own Jekyll theme, and I can consider myself an advanced beginner at the – Liquid template language and CSS stylesheets. By the way, the MDN Web Docs (MDN stands for Mozilla Developer Network, BTW) are awesome. They have tutorials on all the important web technologies: HTML, Javascript, and CSS, plus some more obscure ones. And when you get to the edge cases, they have reference docs.

It took me, basically, all week, with a huge amount of frustration along the way.

We appear to be getting into the bad parts of the week, don't we? Right.

I believe I mentioned that I'd been dreading going home from Betsy's late at night (I'm nowhere near as good a driver as I was at 50, and I know it). My guess is that that was at the root of the anxiety attacks I had Saturday and Sunday. (Panic attacks are intense, and supposedly last for only a few minutes to an hour or so. Anxiety attacks can -- and in my case, do -- last all day.

And I have "Trigger finger" in my left thumb. It's been getting worse, not better, in spite of the brace I'm wearing, which incidentally makes it almost impossible to type because my thumb keeps hitting my laptop's trackpad and left button. Anyway.

Aaaaaaand, I've been spending almost all my time grappling with Jekyll and CSS, and not getting any job applications done. Bletch.

Notes & links, as usual )

mdlbear: (technonerdmonster)

Today in my continuing series on programming languages I'm going to talk about "scripting languages". "Scripting" is a rather fuzzy category, because unlike the kinds of languages we've discussed before, scripting languages are really distinguished by how they are used, and they're used in two very different ways. It's also confusing because most scripting languages are interpreted, and people tend to use "scripting" when they should be using "interpreted". In my opinion it's more correct to say that a language is being used as a scripting language, rather than to say that it is a scripting language. As we'll see, this is particularly true when the language is being used to customize some application.

But first, let's define scripts. A script is basically a sequence of commands that a user could type at a terminal[1] -- often called "the command line" -- that have been put together in a file so that they can be run automatically. The script then becomes a new command. In Linux, and before that Unix, the program that interprets user commands is called a "shell", possibly because it's the visible outer layer of the operating system. The quintessential script is a shell script. We'll dive into the details later.

[1] okay, a terminal emulator. Hardly anyone uses physical terminals anymore. Or remembers that the "tty" in /dev/tty stands for "teletype"'.

The second kind of scripting language is used to implement commands inside some interactive program that isn't a shell. (These languages are also called extension languages, because they're extending the capabilities of their host program, or sometimes configuration languages.) Extension languages generally look nothing at all like something you'd type into a shell -- they're really just programming languages, and often are just the programming language the application was written in. The commands of an interactive program like a text editor or graphics editor tend to be things like single keystrokes and mouse gestures, and in most cases you wouldn't want to -- or even be able to -- write programs with them. I'll use "extension languages" for languages used in this way. There's some overlap in between, and I'll talk about that later.

Shell scripting languages

Before there was Unix, there were mainframes. At first, you would punch out decks of Hollerith cards, hand them to the computer operator, and they would (eventually) put it in the reader and push the start button, and you would come back an hour or so later and pick up your deck with a pile of listings from the printer.

Computers were expensive in those days, so to save time the operator would pile a big batch of card decks on top of one another with a couple of "job control" cards in between to separate the jobs. Job control languages were really the first scripting languages. (And the old terminology lingers on, as such things do, in the ".bat" extension of MS/DOS (later Windows) "batch files". Which are shell scripts.)

By far the most sophisticated job control language ran on the Burroughs 5000 and 6000 series computers, which were designed to run Algol very efficiently. (So efficiently that they used Algol as what amounted to their assembly language! Programs in other languages, including Fortran and Cobol, were compiled by first translating them into Algol.) The job control language was a somewhat extended version of Algol in which some variables had files as their values, and programs were simply subroutines. Don't let anyone tell you that all scripting languages are interpreted.

Side note: the Burroughs machines' operating system was called MCP, which stands for Master Control Program. Movie fans may find that name familiar.

Even DOS batch files had control-flow statements (conditionals and loops) and the ability to substitute variables into commands. But these features were clumsy to use. In contrast, the Unix shell written by Stephen Bourne at Bell Labs was designed as a scripting language. The syntax of the control structures was, in fact, derived from Algol 68, which introduced the "if...fi" and "do...done" syntax.

Bourne's shell was called sh in Unix's characteristically terse style. The version of Unix developed at Berkeley, (BSD, for Berkeley System Distribution -- I'll talk about the history of operating systems some time) had a shell called the C shell, csh, which had a syntax derived from the C programming language. That immediately gave rise to the popular tongue-twister "she sells cshs by the cshore".

The GNU (GNU's Not Unix) project, started by Richard Stallman with the goal of producing a completely free replacement for Unix, naturally had its own rewrite of the Bourne Shell called bash -- the Bourne Again Shell. It's a considerable improvement over the original, pulling in features from csh and some other shell variants.

Let's look at shell scripting a little more closely. The basic statement is a command -- the name of a program followed by its arguments, just as you would type it on the command line. If the command isn't one of the few built-in ones, the shell then looks for a file that matches the name of the command, and runs it. The program eventually produces some output, and exits with a result code that indicates either success or failure.

There are a few really brilliant things going on here.

  • Each program gets run in a separate process. Unix was originally a time-sharing operating system, meaning that many people could use the computer at the same time, each typing at their own terminal, and the OS would run all their commands at once, a little at a time.
  • That means that you can pipe the output of one command into the input of another. That's called a "pipeline"; the commands are separated by vertical bars, like | this, so the '|' character is often called "pipe" in other contexts. It's a lot shorter than saying "vertical bar".
  • You can "redirect" the output of a command into a file. There's even a "pipe fitting" command called tee that does both: copies its input into a file, and also passes it along to the next command in the pipeline.
  • The shell uses the command's result code for control -- there's a program called true that does nothing but immediately returns success, and another called false that immediately fails. There's another one, test, which can perform various tests, for example to see whether two strings are equal, or a file is writable. There's an alias for it: [. Unix allows all sorts of characters in filenames. Anyway, you can say things like if [ -w $f ]; then...
  • You can also use a command's output as part of another command line, or put it into a variable. today=`date` takes the result of running the date program and puts it in a variable called today.

This is basically functional programming, with programs as functions and files as variables. (Of course, you can define variables and functions in the shell as well.) In case you were wondering whether Bash is a "real" programming language, take a look at nanoblogger and Abcde (A Better CD Encoder).

Sometime later in this series I'll devote a whole post to an introduction to shell scripting. For now, I'll just show you a couple of my favorite one-liners to give you a taste for it. These are tiny but useful scripts that you might type off the top of your head. Note that comments in shell -- almost all Unix scripting languages, as a matter of fact -- start with an octothorpe. (I'll talk about octothorpe/sharp/hash/pound later, too.)

# wait until nova (my household server) comes back up after a reboot
until ping -c1 nova; do sleep 10; done

# count my blog posts.  wc counts words, lines, and/or characters.
find $HOME/.ljarchive -type f -print | wc -l

# find all posts that were published in January.
# grep prints lines in its input that match a pattern.
find $HOME/.ljarchive -type f -print | grep /01/ | sort

Other scripting languages

As you can see, shell scripts tend to be a bit cryptic. That's partly because shells are also meant to have commands typed at them directly, so brevity is often favored over clarity. It's also because all of the operations that work on files are programs in their own right; they often have dozens of options and were written at different times by different people. The find program is often cited as a good (or bad) example of this -- it has a very different set of options from any other program, because you're trying to express a rather complicated combination of tests on its command line.

Some things are just too complicated to express on a single line, at least with anything resembling readability, so many other programs besides shells are designed to run scripts. Some of the first of these in Unix were sed, the "stream editor", which applies text editing operations to its input, and awk, which splits lines into "fields" and lets you do database-like operations on them. (Simpler programs that also split lines into fields include sort, uniq, and join.)

DOS and Windows look at the last three characters of a program's name (e.g., "exe" for "executable" machine language and "bat" for "batch" scripts) to determine what it contains and how to run it. Unix, on the other hand, looks at the first few characters of the file itself. In particular, if these are "#!" followed by the name of a program (I'm simplifying a little), the file is passed to that program to be run as a script. The "#!" combination is usually pronounced "shebang". This accounts for the popularity of "#" to mark comments -- lines that are meant to be ignored -- in most scripting languages.

The scripting programs we've seen so far -- sh, sed, awk, and some others -- are all designed to do one kind of thing. Shells mostly just run commands, assign variables, and substitute variables into commands, and rely on other programs like find and grep to do most other things. Wouldn't it be nice if one could combine all these functions into one program, and give it a better language to write programs in. The first of these that really took off was Larry Wall's Perl. Like the others it allows you to put simple commands on the command line -- with exactly the same syntax as grep and awk.

Perl's operations for searching and substituting text look just like the ones in sed and grep. It has associative arrays (basically lookup tables) just like the ones in awk. It can run programs and get their results exactly the way sh does, by enclosing them in backtick characters (`...` -- originally meant to be used as left single quotes), and it can easily read lines out of files, mess with them, and write them out. It has has objects, methods, and (more or less) first-class functions. And just like find and the Unix command line, it has a well-earned reputation for scripts that are obscure and hard to read.

You've probably heard Python mentioned. It was designed by Guido van Rossum in an attempt to be a better scripting language Perl, with an emphasis on making programs more readable, easier to write, and easier to maintain. He succeeded. At this point Python has mostly replaced Perl as the most popular scripting language, in addition to being a good first language for learning programming. (Which is the best language for learning is a subject guaranteed to invoke strong opinions and heated discussions; I'll avoid it for now.) I avoided Python for many years, but I'm finally learning it and finding it much better than I expected.

Extension languages

The other major kind of scripting is done to extend a program that isn't a shell. In most cases this will be an interactive program like an editor, but it doesn't have to be. Extensions of this sort may also be called "plugins".

Extension languages are usually small, simple, and interpreted, because nobody wants their text editor (for example) to include something as large and complex as a compiler when its main purpose is defining keyboard shortcuts. There's an exception to this -- sometimes when a program is written in a compiled language, the same language may be used for extensions. In that case the extensions have to be compiled in, which is usually inconvenient, but they can be particularly powerful. I've already written about one such case -- the Xmonad window manager, which is written and configured in Haskell.

Everyone these days has at least heard of JavaScript, which is the scripting language used in web pages. Like most scripting languages, JavaScript has escaped from its enclosure in the browser and run wild, to the point where text editors, whole web browsers, web servers, and so on are built in it.

Other popular extension languages include various kinds of Lisp, Tcl, and Lua. Lua and Tcl were explicitly designed to be embedded in programs. Lua is particularly popular in games, although it has recently turned up in other places, including the TeX typesetting system.

Lisp is an interesting case -- probably its earliest use as an extension language was in the Emacs text editor, which is almost entirely written in it. (To the point where many people say that it's a very good Lisp interpretor, but it needs a better text editor. I'm not one of them: I'm passionately fond of Emacs, and I'll write about it at greater length later on.) Because of its radically simple structure, Lisp is particularly easy to write an interpretor for. Emacs isn't the only example; there are Lisp variants in the Audacity audio workstation and the Autodesk CAD program. I used the one in Audacity for the sound effects in my computer/horror crossover song "Vampire Megabyte".

Emacs, Atom (a text editor written in JavaScript), and Xmonad are good examples of interactive programs where the same language is used for (most, if not all, of) the implementation as well as for the configuration files and the extensions. The boundaries can get very fuzzy in cases like that; as a Mandelbear I find that particularly appealing.

Another fine post from The Computer Curmudgeon.

mdlbear: (technonerdmonster)

In comments on "Done Since 2018-07-15" we started having a discussion of mirroring and cross-posting DW blog entries, and in particular what my plans are for implementing personal blog sites that mirror all or some of a -- this -- Dreamwidth journal.

Non-techie readers might conceivably want to skip this post.

Where I am now:

Right now, my blog posting process is, well, let's just say idiosyncratic. Up until sometime late last year, I was posting using an Emacs major mode called lj-update-mode; it was pretty good. It had only two significant problems:

  1. It could only create one post at a time, and there was no good way to save a draft and come back to it later. I could live with that.
  2. It stopped working when DW switched to all HTTPS. It was using an obsolete http library, and noone was maintaining either of them.

My current system is much better.

  1. I run a command, either make draft or, if I'm pretty sure I'm going to post immediately, make entry. I pass the filename, without the yyyy/mm/dd prefix, along with an optional title. If I don't pass the title I can add it later. The draft gets checked in with git; I can find out when I started by using git log.
  2. I edit the draft. It can sit around for days or months; doesn't matter. It' an ordinary html file except that it has an email-like header with the metadata in it.
  3. When I'm done, I make post. Done. If I'm posting a draft I have to pass the filename again to tell it which draft; make entry makes a symlink to the entry, which is already in a file called yyyy/mm/dd-filename.html. It gets posted, and committed in git with a suitable commit message.

You can see the code in MakeStuff/blogging on GitHub. It depends on a Python client called charm, which I forked to add the Location: header and some sane defaults like not auto-formatting. Charm is mostly useless -- it does almost everything using a terminal-based text editor. Really? But it does have a "quick-post" mode that takes metadata on the command line, and a "sync" mode that you can use to sync your journal with an archive. Posts in the archive are almost, but not quite, in the same format as the MakeStuff archive; the main difference is that the filenames look like yyyy/mm/dd_HHMM. Close, but not quite there.

There's another advantage that isn't apparent in the code: you can add custom make targets that set up your draft using a template. For example, my "Done since ..." posts are started with make done, and my "Computer Curmudgeon" posts are started with make curmudgeon. There are other shortcuts for River and S4S posts. I also have multiple directories for drafts, separated roughly by subject, but all posting into the same archive.

Where I want to go:

Here's what I want next:

  • The ability to post in either HTML or markdown -- markdown has a great toolchain, including the ability to syntax-color your code blocks.
  • The ability to edit posts by editing the archived post and uploading it. Right now it's a real pain to keep them in sync.
  • A unified archive, with actual URLs in the metadata rather than just the date and time in the filename.
  • The ability to put all or part of my blog on different sites. I really want the computer-related posts to go on Stephen.Savitzky.net (usually shortened to S.S.net in my notes), and a complete mirror on steve.savitzky.net (s.s.net).
  • Cross-links in both directions between my sites and DW.

How to get there:

Here's a very brief sketch of what needs to be done. It's only vaguely in sequence, and I've undoubtedly left parts out. But it's a start.

Posting, editing, and archiving

  • Posting in HTML or markdown is a pretty easy one; I can do that just by modifying the makefiles and (probably) changing the final extension from .html to .posted so that make can apply its usual dependency-inference magic.
  • Editing and a unified archive will both require a new command-line client. There aren't any. There are libraries, in Ruby, Haskell, and Javascript, that I can wrap a program around. (The Python code in charm doesn't look worth saving.) I wanted to learn Ruby anyway.
  • The unified archive will also require a program that can go back in time and match up archived posts with the right URLs, reconcile the two file naming conventions, and remove the duplicates that are due to archiving posts both in charm and MakeStuff. Not too hard, and it only has to be done once.
  • It would be nice to be able to archive comments, too. The old ljbackup program can do it, so it's feasible. It's in Perl, so it might be a good place to start.

Mirror, mirror, on the server...

This is a separate section because it's mostly orthogonal to the posting, archiving, etc.

  • The only part of the posting section that really needs to be done first is the first one, changing the extension of archived posts to .posted. (That's because make uses extensions to figure out what rules to apply to get from one to another. Remind me to post about make some time.)
  • The post archive may want to have its own git repository.
  • Templating and styling. My websites are starting to show their age; there's nothing really wrong with a retro look, but they also aren't responsive (to different screen sizes -- that's important when most people are reading websites on their phones), or accessible (screen-reader friendly and navigable by keyboard; having different font sizes helps here, too). Any respectable static site generator can do it -- you may remember this post on The Joy of Static Sites -- but the way I'm formatting my metadata will require some custom work. Blosxom and nanoblogger are probably the closest, but they're ancient. I probably ought to resist the temptation to roll my own.

Yeah. Right.

Another fine post from The Computer Curmudgeon.

mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

Hmm. Moderately productive week? Not so much on the job search: one phone screen, and one application submitted. They're interesting ones, however: the phone screen was for SUSE, a Linux distribution; the application was for a half-time junior engineer position at ISC (the Internet Software Consortium, makers of bind9, bind10, and isc-dhcp). I would really like to land that last one because of the half-time aspect, but either would be cool.

The ISC job description mentioned working with the IETF, which led by a comparatively short chain of links to this week's Songs for Saturday post. SUSE led to me installing the latest version of openSUSE (Leap 15; they have several) on one of my spare laptops. Interesting. It's RPM-based and favors KDE as a desktop; I'm not crazy about either one, and a lot of the defaults and other choices are,... odd. But, it's something else to put in my toolkit.

A fair amount of project time was also taken up by system administration -- my mirror drive apparently died in last week's power failure. Ugh. Fortunately I had a 700Gb laptop drive ready to go in a USB enclosure; not as big as the original mirror, but that wasn't anywhere near full. The mirror is 87% full, which isn't bad. A little project time also went into starting a React Native app based on the PHQ-9 and GAD-7 psych screeners; all of that was basically reading, setup, and tracking down the content.

Aside from S4S, I also got to sing with N last Sunday, and I had a good singing lesson. So there was music.

There was also posting -- S4S, a fishbowl signal boost, Thankful Thursday, and the latest Computer Curmudgeon post. I'm pretty happy with the positive response to that one; my inclination is to do scripting languages next.

Notes & links, as usual )

mdlbear: (technonerdmonster)
Back when smalltalk was sports and the weather, And an object was what you could see, And we watched "Captain Video" in black-and-white, Before there was color TV. -- "When I Was a Lad"

Even if you're not a programmer (and most of the people I expect to be reading this aren't) you've probably heard one of your geek friends mentioning "object-oriented" programming. You might even have heard them mention "functional" programming, and wondered how it differs from non-functional programming. The computer curmudgeon can help you.

If you are a programmer, you probably know a lot of this. You may find a few items of historical interest, and it might be useful explaining things to the non-programmers in your life.

Imperative languages

As you may recall from last month's post on computer languages, the first programming languages were assembly languages -- just sequences of things for the computer to do, one after another (with a few side-trips). This kind of language is called "imperative", because each statement is a command telling the computer what to do next: "load a into register 2!" "add register 2 to register 3!" "roll over!" "sit!" You get the idea.

Most programmers use "statement" instead of "command" for these things even though the latter might be more correct from a grammatical point of view; a "command" is something one types at a terminal in order to run a program (which is also called a "command").

Most of the earlier programming languages (with one notable exception that we'll get to later) were also imperative. Fortran, Cobol, and Algol were the most prominent of these; most of today's languages descend more-or-less from Algol. (By the way, the Report on the Algorithmic Language Algol 60 is something I always point to as an example of excellent technical writing.)

Imperative languages make a distinction between statements, which do things (like "a := 2", which puts the number 2 into a variable called "a"), and "expressions", which compute results. Another way of saying that is that an expression has a value (like 2+2, which has a value of 4), and a statement doesn't. In earlier languages that value was always a number; later languages add things like lists of symbols and strings of characters enclosed in quotes.

Algol and its descendents lend themselves to what's called "Structured Programming" -- control structures like conditionals ("if this then {that} else {something-else}") and loops (for x in some-collection do {something}) let you build your program out of simple sections that nest together but always have a single entrance and exit. Notice the braces around those sections. Programming languages have different ways of grouping statements; braces and indentation are probably the most common, but some languages use "if ... fi" and "do ... done".

Languages also have ways of packaging up groups of statements so that they can be used in different places in the program. These are called either "subroutines" or "functions"; if a language has both it means that a function returns a value (like "sqrt(2)", which returns the square root of 2) and a subroutine doesn't (like "print('Hello world!')", which prints a familiar greeting.) Subroutines are statements, and functions are expressions. The expressions in parentheses are called either "arguments" or "parameters" -- I was bemused to find out recently that verbs have arguments, too. (A verb's arguments are the subject, and the direct and indirect objects.)

Object-oriented languages

As long as we're on the subject of objects, ...

In the mid 1960s Ole-Johan Dahl and Kristen Nygaard, working at the University of Oslo, developed a language called Simula, designed for simulating objects and events in the real world. Objects are things like cars, houses, people, and cats, and Simula introduced software objects to represent them. Objects have "attributes": my car is blue, my cats are both female, my wife has purple hair. Some of these attributes are objects in their own right: a car has wheels, a cat has four legs and a person has two legs and two arms. Some of these are variables: sometimes my driveway has a car in it, sometimes it doesn't, and sometimes it has two or three.

What this means is that objects have state. A car's speed and direction vary all the time, as does the position of a cat's tail. An object is a natural way to bundle up a collection of state variables.

An object also can do things. In a program, objects rarely do things on their own, some other object tells them what to do. This is a lot like sending the object a message. "Hey, car -- turn left!" "Hey, cat! What color are your eyes?" Software objects don't usually have any of their state on the outside where other parts of the program can see it; they have to be asked politely. That means that the object might be computing something that looks to the outside like a simple state variable -- a car computes its speed from the diameter of its tires and how fast its wheels are turning. All these things are hidden from the rest of the program.

An object has to have a method for handling any message thrown at it, so the documentation of most languages refers to "calling a method" rather than "sending a message". It's the same thing in most cases. As seen from the outside, calling a method is just like calling a function or subroutine, except that there's an extra argument that represents the object. If you think of the message as a command -- an imperative sentence -- it has an implied subject, which is the object you're talking to. Inside the little program that handles the method, the object is represented by a name that is usually either "self" or "this", depending on the language.

One natural thing to do with objects is to classify them, so objects have "classes", and classes tend to be arranged in hierarchies. My cats are cats -- we say that Ticia and Desti are instances of the class "Cat". All cats are animals, so Cat is a subclass of Animal, as are Dog and Person. (In programming languages, classes tend to have their names capitalized. Variables (like "x" or "cat") almost always start with a lowercase letter. Constants (like "Pi", "True", and "Ticia") can go either way.)

An object's class contains everything the computer needs to determine the behavior of its instances: a list of the state variables, a list of the methods it can handle, and so on. Now we get to the fun part.

Simula was just objects and methods tacked on to a "traditional" imperative language -- Algol in that case. Most other "object-oriented" languages work the same way -- C++ is just objects tacked on to C; Python and Perl had objects from the beginning or close to it, but they still include a lot of things -- numbers, strings, arrays, and so on, that aren't objects or (like strings in Java) are pretending to be objects. It doesn't have to be that complicated.

Shortly after Simula was released, Alan Kay at Xerox PARC realized that you could design a programming language where everything was an object. The result was Smalltalk, and it's still the best example of a pure object-oriented language. (It inspired C++ and Java, and indeed almost all existing OO languages, but very few of them went all the way. Ruby comes closest of the languages I'm familiar with.) Smalltalk is turtles objects all the way down.

In Smalltalk numbers are objects -- you can add new methods to them, or redefine existing methods. (Your program will eventually stop working if you redefine addition so that 2+2 is 5, but it will keep going for a surprisingly long time.) So are booleans. True and False are instances of different subclasses of Boolean, and they behave differently when given messages like ifTrue: or ifFalse:. (I'm not going to go into the details here; Smalltalk warrants an article all by itself). Loops are methods, too. The trickiest bit, though, is that classes are objects. A class is just an instance of Metaclass, and Metaclass is an instance of itself.

Someone trying to implement Smalltalk has to cheat in a couple of places -- the Metaclass weirdness is one of them -- but they have to hide their tracks and not get caught.

Functional languages

Smalltalk, for all its object orientation, is still an imperative language underneath. A program is still a sequence of statements, even if they're all wrapped up in methods. Objects have state -- lots of it; they're just a good way of organizing it. Alan Kay once remarked that programming in Smalltalk was a lot like training a collection of animals to perform tricks together. Sometimes it's more like herding cats.

But it turns out that you don't need statements -- or even state -- at all! All you need is functions.

About the same time Alan Turing was inventing the Turing Machine, which is basically a computer stripped-down and simplified to something that will just barely work, Alonzo Church was developing something he called the Lambda Calculus, which did something similar to the mathematical concept of functions.

A mathematical function takes a set of inputs, and produces an output. The key thing about it is that a given set of inputs will always produce exactly the same output. It's like a meat grinder -- put in beef, and you get ground beef. Put in pork, and you get ground pork. A function has no state, and no side-effects. State would be like a secret compartment in the meat grinder, so that you get a little chicken mixed in with your ground beef, and beef in your ground pork. Ugh. A side effect would be like a hole in the side that lets a little of the ground meat escape.

Objects are all about state and side effects. You can call a method like "turn left" on a car (in most languages that would look like car.turn(left)) and as a side effect it will change the car's direction state to something 90 degrees counterclockwise from where it was. That makes it hard to reason about what's going to happen when you call a particular method. It's even harder with cats.

Anyway, in lambda calculus, functions are things that you can pass around, pass to other functions, and return from functions. They're first class values, just like numbers, strings, and lists. It turns out that you can use functions to compute anything that you can compute with a Turing machine.

Lambda calculus gets its name from the way you represent functions: To define a function that squares a number, for example, we say something like:

square = λ x: x*x

Now, this looks suspiciously like assigning a value to a variable, and that's exactly what it's doing. If you like, you can even think of λ as a funny kind of function that takes a list of symbols and turns it into a function. You find the value of an expression like square(3) by plugging the value 3 into the function's definition in place of x. So,

square(3)
  → (λ x: x*x)(3)
  → 3*3
  → 9

Most functional languages don't allow you to redefine a name once you've bound it to a value; if you have a function like square it wouldn't make much sense to redefine it in another part of the program as x*x*x. This is vary different from imperative languages, where variables represent state and vary all over the place. (Names that represent the arguments of functions are only defined inside any one call to the function, so x can have different values in square(2) and square(3) and nobody gets confused.)

Lambda calculus lends itself to recursive functions -- functions that call themselves -- and recursion is particularly useful when you're dealing with lists. You do something to the first thing on the list, and then combine that with the result of doing the same thing to the rest of the list.Suppose you have a list of numbers, like (6 2 8 3). If you want another list that contains the squares of those numbers, you can use a function called map that takes two arguments: a function and a list. It returns the result of applying the function to each element of the list. So

map(square, (6, 2, 8, 3))
 → (36, 4, 64, 9)

It's pretty easy to define map, too. It's just

map = λ (f, l):
	if isEmpty(l)
           then l
	   else cons(f(first(l)), map(f, rest(l)))

The cons function constructs a new list that consists of its first argument, which can be anything, tacked onto the front of its second argument, which is a list. Using first and rest as the names of the functions that get the first item in a list, and the remainder of the list after the first item, is pretty common tese days. Historically, the function that returns the first item in a list is called car, and the function that returns the rest of the list is called cdr (pronounced sort of like "could'r").

I know, the classic introduction to recursive functions is factorial. Lists are more interesting. Besides, I couldn't resist an excuse for mentioning "car". We'll see "cat" in a future post when I discuss scripting languages.

We call map a "higher-level" function because it takes a function as one of its arguments. Other useful higher-level functions include filter, which takes a boolean function (one that returns true or false) and flatmap, which takes a function that returns lists and flattens them out into into a single list. (Some languages call that concatmap.) Higher-level functions are what make functional languages powerful, beautiful, and easy to program in.

Now, Church's lambda calculus was purely mathematical -- Church used it to prove things about what kinds of functions were computable, and which weren't, which is exactly what Alan Turing did with the Turing Machine. We'll save that for another post, except to point out that Church's lambda calculus can compute anything that a Turing machine can compute, and vice versa.

But in 1958 John McCarthy at MIT invented a simple way of representing lambda expressions as lists, so that they could be processed by a computer: just represent a function and its arguments as a list with the function first, followed by its arguments. Trivial? Yes. But brilliant. His paper included a simple function called eval that takes a list representing a function and its arguments, and returns the result. Steve Russell realized that it wouldn't be hard to implement eval in machine language (on an IBM 704).

I'll save the details for another post, but the result was a language called Lisp. It's the second oldest programming language still in use. The post about LISP will explain how it works (elsewhere I've described eval as The most amazing piece of software in the world), and hopefully show you why Kanef's song The Eternal Flame says that God wrote the universe in LISP. Programmers may want to take a look at "Sex and the Single Link".

And finally,

I'd be particularly interested in seeing comments from the non-programmers among my readers, if I haven't lost you all by now. Was this post interesting? Was it understandable? Was it too long? Were my examples sufficiently silly? Inquiring minds...

Another fine post from The Computer Curmudgeon.

mdlbear: (technonerdmonster)

Here are a couple of little tricks that may keep you from tearing your hair out in frustration, and in any case will make your posts look better.

Tip the first: Make beautiful poetry with no effort.

There are two obvious ways to post poetry: enclose it in <pre>...</pre> tags (which tells the browser that it's preformatted, so it should leave your line breaks alone), or tediously add a line break tag -- <br> -- to the end of every line. Unfortunately, preformatted text uses a monospaced font, which is great for code and concrete poetry, but really doesn't look very good. And adding line breaks is just tedious.

There is a third way: use

<blockquote style="white-space: pre-wrap;" >to wrap your poem. </blockquote>

This tells your browser to keep spaces and line breaks the way you want them, but continue using the same font as the rest of your page.

There's one subtlety: that start tag is pretty long, but if you start your poem on the following line there will be an annoying extra blank line at the top. So do what I did up there, and start a new line before the >. It turns out that you can replace spaces with newlines anywhere outside of quotes.

That brings me to the next tip:

Tip the Second: Don't let your word processor try to help.

A lot of people compose their blog posts using a word processor, and paste them into the "post" form. If you don't, and aren't using some kind of posting client that lets you save your work any time you want to, you should. Especially if you have cats. But there's a problem. Word processors want to help you create great-looking documents. And that's a problem if you're trying to write HTML.

One thing word processors may try to do is to replace all your quotation marks with “curly” quotes (also called “smart” quotes), instead of using "straight" quotes. That's great except for when you're trying to enter a link, or one of style attributes I just showed you up above. A browser won't recognize them. So instead of

<a href="https://steve.savitzky.net">this</a>

you get

<a href=“https://steve.savitzky.net”>this</a>

See the difference? You may have to zoom in a little. Hover over the links. You'll see that your browser thinks that it's looking at a local link, because it doesn't start with https://, it starts with “https://! Oops!

Another thing I've seen word processors and some other programs do is, behind your back, replace "<" and ">" characters with "&lt;" and "&gt;". Those weird things are called "character entities", and they're HTML's way of forcing the browser to show something that looks like "<" without letting it interpret it as part of a tag. That probably isn't what you wanted, unless you're trying to write math inequalities or an article about how to write HTML.

Yet another problem happens because word processors use proportional spacing, so that your post looks to you the way it's going to look in a browser, more or less. The problem happens because some characters are really small in proportional-spaced fonts, so it's hard to select exactly the text you wanted to, and easy to overlook stray spaces and periods if they get pasted into your links by mistake.

That's why programmers use text editors with fixed-width fonts, and rely on programs like web browsers and LaTeX to make their pages look good when you read or print them.

 

By the way, I did a little searching and found The Mandelbear's Rough Guide to HTML, from back in 2006. It's still mostly good advice.

Another fine post from The Computer Curmudgeon.

mdlbear: (technonerdmonster)

If you develop software and haven't just returned from the moon, you've undoubtedly heard that GitHub is being acquired by Microsoft. Depending on your affiliations you might be spelling "being acquired by" as "selling out to". The rest of you are probably wondering what on Earth a GitHub is, and why Microsoft would want one. Let me explain.

Please note: this post isn't about my opinion of today's news. It's really too early to tell, though I may get into that a little toward the end. Instead, I'm going to explain what GitHub is, and why it matters. But first I have to explain Git.

Git is a version-control system. (Version-control systems are sometimes called "source code management" (SCM) systems. If you look closely you might even have spotted "scm" in git's URL up there at the end of the last paragraph.) Basically, a version-control system lets you record the complete history of a project, with what changes were made, who made the each change, when they changed it, and their notes about what they did and why. It doesn't have to be a software project, either. It can be recipes, photographs, books, the papers you're writing for school, or even blog entries. (Yes, I do.)

Before git, most version-control systems kept track of changes in text files (which of course is what all source code is) by recording which lines are different from the previous version. (It's usually done by a program called diff.) This was very compact, but it could also be very slow if you had to undo all the changes between two versions in order to see what the older one looked like.

Git, on the other hand, is blindingly fast in part because it works in the stupidest way possible (which is why it's called "git"). It simply takes the new version of each file that changed since the last version, zips it up, and stuffs it whole into its repository. So it takes git about the same amount of time to roll a file back two versions or two hundred.

The other thing that makes git fast is where it keeps all of its version information. Before git, most version-control systems used a centralized repository on a server somewhere. (Subversion, one of the best of these, even lets you browse the repository with a web browser.) That means that all the change information is going over a network. Git keeps its repository (these days everyone shortens that to "repo") on your local disk, right next to your working copy, in a hidden subdirectory called ".git".

Because its repo is local, and contains the entire history of your project, you don't need a network connection to use git. On the beach, in an airplane, on a boat, with a goat, it doesn't matter to git. It's de-centralized. It gets a little more complicated when more than one developer is working on a project.

Bob's been in the office all week working on a project. When his boss, Alice, comes back from the open source conference she's been at all week, all she has to do is tell git to fetch all the changes that Bob made while she was away. Git gets them directly from Bob's repo. If Alice didn't make any changes, that's called a "fast-forward" merge -- git just takes the changes that Bob made, copies those files into Alice's repo, updates her working tree, and it's done.

It's a little trickier if Alice had time to make some changes, too. Now Alice has to merge the two sets of changes, and then let Bob pull the merged files onto his computer. By the way, a "pull" is just a fetch followed by a merge, but it's so common that git has a shorthand way of doing it. (I'm oversimplifying here, but this isn't the time to go into the difference between merge and rebase. It's also not a good time to talk about branches -- maybe some other week.) As you can imagine, this gets out of hand pretty quickly, and it's even worse if there's a whole team working on the project.

The obvious thing to do is for the group to have one repo on a server somewhere that has what everyone agrees is the definitive set of files on it. Bob pushes his changes to the server, and when Alice tries to push her changes, git balks and gives her an error message. Now it's Alice's responsibility to make any necessary fixes and push them to the server. Actually, in a real team, Alice would send her proposed changes around by making a diff and sending email to the other team members to review, and not actually push her changes until someone approves them.

In a large team, this is kind of a hub-and-spokes arrangement. You can see where this is going, right?

GitHub is a company that provides a place for people and projects to put shared git repositories where other people can see them, clone them, and contribute to them. GitHub has become wildly popular, because it's a great place to share software. If you have an open-source software project, putting a public repo on GitHub is the most effective way to reach developers. It's so popular that Google and Microsoft shut down their own code-hosting sites (Google Code and CodePlex respectively) and moved to GitHub. Microsoft, it turns out, is GitHub's biggest contributor.

Putting a public repository on GitHub is free. If you want to set up private repositories, GitHub will charge you for it, and if your company wants to put a clone of GitHub on its own private servers they can buy GitHub Enterprise, but if your software is free, so's your space on GitHub.

That's a bit of a problem, because the software that runs GitHub is not free. That means that they need a steady stream of income to pay their in-house developers, because they're not going to get any help from the open-source developer community. GitHub lost $66 million in 2016, and doesn't really have a sustainable business model that would make them attractive to investors. They needed to get acquired, or they had a real risk of going under. And when a service based on proprietary software goes under, all of their customers have a big problem. But their users? Heh.

Everybody knows the old adage, "if you're getting a service for free you're not the customer, you're the product." That's especially true for companies like Google and Facebook, which sell their users' eyeballs to advertisers. It's a lot less true for a company whose users can leave any time they want, painlessly, taking all their data and their readers with them. I'm sure most of my readers here on Dreamwidth remember what happened to Livejournal when they got bought by the Russians. Well, GitHub is being bought by Microsoft. It's not entirely clear which is worse.

GitHub has an even worse problem than Livejournal did, because "cross-posting" is basically the way git works. There's a company called GitLab that looks a lot like GitHub, except that their core software -- the stuff that wraps a slick web interface around a git repository -- is open source. (They do sell extensions, but most projects aren't going to need them.) If you want to set up your own private GitLab site, it's free, and you can do it in ten minutes with a one-line command. If you find bugs, you can fix them yourself. You'll find a couple of great quotes from their blog at the end of the notes, but the bottom line is that 100,000 repositories have moved from GitHub to GitLab in the last 24 hours.

And once you've moved a project to GitLab, you don't have to worry about what happens to it, because the open-source core of it will continue to be maintained by its community. That's what happened when a company called Netscape went belly-up: Mozilla Firefox is still around and doing fine. And if the fact that GitLab is for profit is a problem for you, there's Apache Allura, gitolite3, gitbucket, and gitweb (to name a few). Go for it!

 

This so wasn't what I was planning to write today.

Notes:
  @ Microsoft Reportedly Acquires GitHub | Linux Journal
    The article ends with a list of alternatives:
    Gitea
    Apache Allura
    GitBucket: A Git platform
    GitLab
  @ Microsoft acquires GitHub for $7.5 billion - TFiR
    " According to reports, GitHub lost over $66 millions in 2016. At the same time
      GitLab, a fully open source and decentralized service is gaining momentum, giving
      users a fully open source alternative. "
  @ Microsoft to acquire GitHub for $7.5 billion | Stories official press release
  @ Microsoft + GitHub = Empowering Developers - The Official Microsoft Blog
  @ A bright future for GitHub | The GitHub Blog
  @ Congratulations GitHub on the acquisition by Microsoft | GitLab
    " While we admire what's been done, our strategy differs in two key areas. First,
      instead of integrating multiple tools together, we believe a single application,
      built from the ground up to support the entire DevOps lifecycle is a better
      experience leading to a faster cycle time. Second, it’s important to us that the
      core of our product always remain open source itself as well. "
  @ GitLab Ultimate and Gold now free for education and open source | GitLab 
    " It has been a crazy 24 hours for GitLab. More than 2,000 people tweeted about
      #movingtogitlab. We imported over 100,000 repositories, and we've seen a 7x increase
      in orders. We went live on Bloomberg TV. And on top of that, Apple announced an
      Xcode integration with GitLab. "

Another fine post from The Computer Curmudgeon.

mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

I have been working much of the time with my laptop closed and one of my little USB Thinkpad keyboards sitting on top of it. This is both because Cygnus's keyboard seems to be deteriorating (the "f" key, in particular, is unreliable), and because cats. Having a separate keyboard that can be put to one side and leaned against the wall isn't a complete solution to the latter problem (kittens are zoomy), but it helps.

I have been gradually emptying the boxes of CDs and putting them on shelves in the towers. I'm basically done, except that things other than classical and folk/filk/rock/pop haven't been sorted yet, just put in haphazardly. What's left are the CDs that I brought in from Rosie, the ones in drawers in the cabinet under the stereo, and anything still in the pod. The latter category is of unknown size at this point.

Taxes are mostly done at this point, but I need to get off my arse about the remaining bits. Otherwise said arse might get bitten by them.

I need to blog more, and do more programming than simply bug fixes and tweaks. That implies that I should

  1. Start a couple of projects. (At least one front-end project, and at least one app.) Expect a planning post soon.
  2. Blog about them as I go.

Geeks in my audience will want to know about 1.1.1.1: Cloudflare's fast, privacy-first consumer DNS service. Not only is it significantly faster than any of the others (e.g. Google's 8.8.8.8), it uses encryption if you're set up for it, and doesn't save logs to disk. If none of that makes any sense to you, just go to 1.1.1.1, follow the simple installation instructions, and watch your browser get faster.

Simple explanation for non-geeks: It's not actually making websites transfer data any faster -- what it's doing is reducing the time it takes to find the website in the first place, along with any other scripts, ads, and images it may be trying to load.

Geeks interested in making their websites actually load faster should check out Friday's notes about Cutting the mustard. That's all about responsive design. One of the aforementioned projects will involve a makeover of at least one of my websites.

Things have been stressful lately. We'll get through it, but it's going to be rough for a while. More later, perhaps.

Notes & links, as usual )

mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

TL;DR: Patch your computer NOW! (Or as soon as you can, if you're running Windows or Ubuntu and reading this on Monday -- the official release date for this information was supposed to have been Tuesday January 9th.)

Unless you've been hiding under a rock all weekend, you probably know that Meltdown and Spectre have nothing to do with either nuclear powerplants or shady investments: they are, instead, recently-revealed, dangerous design flaws in almost all recent computers. Meltdown affects primarily Intel processors (i.e. most desktops, laptops, and servers), and will be mitigated (Don't you just love that word? It doesn't mean "fixed", it means "made less severe". That's accurate.) by the recent patches to Linux, Windows, and MacOS. Spectre is harder to exploit, but also harder to fix, and may well present serious problems going forward.

But what the heck are they? I'm going to try to explain that in terms a non-geek can understand. Geeks can find the rest of the details in the links, if they haven't already chased them down themselves. (And if you're in software or IT and you haven't, you haven't been paying attention.)

Briefly, these bugs are hardware design problems that allow programs to get at information belonging to other programs. In the case of Meltdown, the other program is the operating system; with Spectre, it's other application programs. The information at risk includes things like passwords, credit card and bank account numbers, and cryptographic keys. Scared yet?

Basically, it all comes down to something called "speculative execution", which means something like "getting stuff done ahead of time just in case it's needed." And carefully putting things back the way they were if it turned out you didn't. That's where it gets tricky.

Modern computers are superscalar, which means that they achieve a lot of their impressive speed by doing more than one operation at once, and playing fast-and-loose with the order they do them in when it doesn't matter. Sometimes they make tests (like, "is this number greater than zero?", or "is that a location the program doesn't have permission to read?"), and do something different depending on the result. That's called a "branch", because the program can take either of two paths.

But if the computer is merrily going along executing instructions before it needs their results, it doesn't know which path to take. So, in the case of Spectre, it speculates that it's going to be the same path as last time. If it guesses wrong (and Spectre makes sure that it will by going down the safe path first), the computer will get an instruction or two down the wrong path before it has to turn back and throw away any results it got. Spectre makes it do something with those results that leaves a trace.

In the case of Meltdown, the test that's going down the wrong path is to see whether the program is trying to read from memory that belongs to the operating system kernel -- that's the part of the OS that's always there, managing resources like memory and files, creating and scheduling processes, and keeping programs from getting into places where they aren't permitted. (There's a lot of information in the kernel's memory, including personal data and passwords; for this discussion you just need to know that leaking it would be BAD.) When this happens, the memory-management hardware interrupts the program before it receives its ill-gotten data; normally the result is that the program is killed. End of story. On Intel processors, though, there's a way the program can say something like "if this instruction causes an interrupt, just pretend it never happened." The illegally-loaded data is, of course, thrown away.

Meltdown works because the operating system's memory is -- or was -- part of the same "address space" as the application program. The application can try to read the kernel's memory; it just gets stopped if it tries. After Tuesday's patch, the two address spaces are going to be completely separate, so the program can't even try -- the kernel's address space simply isn't there. (There's a performance hit, because switching between the two address spaces takes time -- that's why they were together in the first place.)

At this point you know what Spectre and Meltdown do, but you may be wondering how they manage to look at data that simply isn't there any more, because the instruction that loaded it was canceled. (If you're not wondering that, you can stop here.) The key is in the phrase "any more". During the brief time when the data is there, the attacker can do something with it that can still be detected later. The simplest way is by warming the cache.

Suppose you go out to your car on an icy morning and the hood feels warm. Maybe one of the local hoodlums took it out for a joyride, or maybe one of the neighbor's cows was sitting on it. You can tell which it was by starting the engine and seeing whether it's already warmed up. (We're assuming that the cow doesn't know how to hotwire a car.) The attack program does almost the same thing.

The computer's CPU (Central Processing Unit) chip is really fast. It can execute an instruction in less than a nanosecond. Memory, on the other hand, is comparatively slow, in part because it's not part of the CPU chip -- electrical signals travel at pretty close to the speed of light, which is roughly a foot per nanosecond. There's also some additional hardware in the way (including the protection stuff that Meltdown is sneaking past), which slows things down even further. We can get into page tables another time.

The solution is for the CPU to load more memory than it needs and stash (or cache) it away in very fast memory that it can get to quickly, on the very sensible grounds that if it needs something from location X now, it's probably going to want the data at X+1 or somewhere else in the neighborhood pretty soon. The cache is divided into chunks called "lines" that are all loaded into the cache together. (Main memory is divided into "pages", but as I mentioned in the previous paragraph that's another story.)

When it starts a load operation, the first thing the CPU does is check to see whether the data it's loading is in the cache. If it is, that's great. Otherwise the computer has to go load it and the other bytes in the cache line from wherever it is in main memory, "warming up" the cache line in the process so that the next access will be fast. (If it turns out not to be anyplace the program has access to, we get the kind of "illegal access exception" that Meltdown takes advantage of.)

The point is, it takes a lot longer to load data if it's not in the cache. If one of the instructions that got thrown away loaded data that wasn't in the cache, that cache line will still be warm and it will take less time to load data from it. So one thing the attack program can do is to look at a bit in the data it's not supposed to see, and if it's a "1", load something that it knows isn't in the cache. That takes only two short instructions, so it can easily sneak in and get pre-executed.

Then, the attack program measures how long it takes to load data from that cache line again. (One of the mitigations for the spectre attack is to keep Javascript programs -- which might come from anywhere, and shouldn't be able to read your browser's stored passwords and cookies -- from getting at the high-resolution timers that would let them measure load time.)

Here under the cut are a basic set of references, should you wish to look further. Good stuff to read while your patches are loading.

Notes & links )

mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

Not a bad week, I guess. Right now I'm feeling pretty down and hopeless, partly because of this article about Trump plus the fact that my family's economic future depends largely on Social Security and Medicare, which Trump's government seems hell-bent on destroying; and partly... I don't know what. I don't think depression and anxiety need a reason.

I did manage to figure out approximately what I should have been withholding for taxes; I also found out that the deadline for the second quarter's estimated tax payment was last month, so I'm slightly more screwed than I thought I was. Only slightly. That adds to the anxiety, of course.

N. and the kids have been away since Wednesday morning, with N and g at OVFF. It's been a bit lonely. I have, however, been getting things done, including putting up shelves and a little artwork, and setting up my desk with what amounts to a dual-monitor setup with the external monitor above Cygnus. I'm using the traditional makeshift monitor stand: a ream of printer paper. I actually did find my other Thinkpad keyboards, but with Cygnus on the desk I don't need them.

Our second week of prepared menus has worked out pretty well, though I did end up going out shopping Tuesday for some things that I'd missed on Sunday, and a little bit on Friday. It does seem as though we're spending less. I've also determined that I have to go grocery shopping alone -- it's impossible for me to stick to a list if there's someone else along. I really have difficulty saying "no" to anybody, and it's stressful.

Yesterday Colleen and I went to the Bayview farmer's market after picking up the bike helmet we'd ordered. Bought lunch (samosas) and some jam. See above about saying "no".

I did manage to say "no" to the life insurance agent. Yes, it's great that I was able to qualify for the lowest possible rate, which means I'm a lot healthier than most septuagenarians. But my financial advisor, who I consulted last Friday, pointed out that since my social security, IRA, and pension between them are enough to keep us going; unlike the situation in Seattle, we're not relying on my salary to pay the mortgage. (Colleen's SS payment is half of mine and will go away after I die; it does make a difference but the family would still get by without it.)

The thing that still scares the hell out of me is what would happen if I don't die, but simply get incapacitated, or if either Colleen or I end up needing more expensive care. Then we're hosed.

Notes & links, as usual )

mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

On the whole a pretty good week. (I was going to say, "not a bad week", but it may actually qualify for good this time. I'm really bad at evaluating subjective stuff like that.)

I got my taxes done. Probably still some things missing, but since I only owed $117 over what I estimated back in April I'm not going to complain. Much. I'm still in a world of trouble over the lack of withholding on some of the pensions. That's going to bite me. Well, I'll put in an estimated payment for the quarter; that will help.

Naomi came home Sunday with the scooters, and we got one of them out of the van. (G and I got the other out last night with the help of my folding ramp.) And yesterday on the way home from dinner out we stopped at the bike shop in Bayview and ordered Colleen a (purple, of course) helmet.

Meanwhile, I have reconfirmed my dislike for the Mac user interface (Windows would be worse). The main reason is the inconsistent bindings for control, meta, and super (the "logo" key). It's almost tolerable with a Thinkpad keyboard and x2vnc, but the key bindings in Emacs are wonky and cut-and-paste doesn't work between the two systems.

Also, of course, Raven's handling of its external monitor is broken, and the desk isn't wide enough for it plus the monitor anyway. (It is wide enough for Cygnus to the left of the monitor, so I may end up doing that.) I have Raven on a tray table to the right of the monitor, which isn't ideal because, oh, yeah: my newest Thinkpad keyboard has started dropping keystrokes. Basically unusable at this point, and it's only a year old. Lenovo's QC has really tanked -- I miss IBM. And I can't find the box with my other keyboards :P Unlike the drill and the router, I know that one is in the garage because I saw it there. I blame the cats.

The cats are all doing okay. Even Bronx, who remains a bit fragile and isn't eating all that well.

We are making progress toward making the room over the garage into a usable living space. By not making large structural changes, and not making it an official ADU, we can probably save a lot.

Notes & links, as usual )

mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

This marks the first week for which, at N's suggestion, Colleen and I prepared a weekly menu in advance. It came out fairly well -- you can see it at the end of the notes. There were a couple of substitutions, but on the whole it was a success. We did the same this week.

I got a fair amount done. Unfortunately, very little of it was my taxes; that's the top project for this week. I did, however, get the Mac set up and the program I still think of as TaxCut (currently called "H&R Block at Home" or something like that) updated. The Mac, Whitewood, is set up on my desk, with (ThinkPad) Raven next to it on a tray table. There's a little story about that...

You see, sometime Friday morning I managed to spill some coffee onto my little ThinkPad, Cygnus. I shut it down and left it to dry out. An hour or so later, it booted, but some of the keys on the lower right-hand corner were flaky, and I couldn't get it to accept my hard drive password. That's when I set up Whitewood and Raven. Fortunately I had pushed recently, so Raven was able to sync right up and be productive.

Then, since I had a Linux laptop and a Mac mini with a nice large monitor, the obvious next step was to install x2vnc and share the Mac's keyboard (a ThinkPad keyboard, of course -- I'd had it at work), trackball, and mouse. I put those all on a KVM switch (which I don't use for monitors, only for USB, because switching a VGA monitor confuses my computers). Win. It took altogether too much time to figure out that the reason x2vnc didn't seem to be connecting was that Apple's implementation puts up a lock screen when you first connect. :P

x2vnc is pretty cool -- it lets you share a keyboard and mouse between two computers, using VNC's screen-sharing in the input direction, but not actually viewing the screen. Instead, you just move the cursor onto the other machine's screen, across whichever edge you specify.

The other tech-related failure Friday was that my attempt to replace the charging port on Colleen's old tablet was unsuccessful. Quite possibly the flat cable isn't seated correctly. It was a bit of a long shot, though I would have liked to be able to at least do a factory reset.

I spent quite a lot of time Friday looking up ways of unlocking a password-protected hard drive when one doesn't have a working computer to enter the password into. Apparently Lenovo changes their password hashing algorithm every so often, so you have to get a ThinkPad that was made close enough to the time your dead one was. Ouch! I didn't really care too much about the data, since it was all backed up, but that was a comparatively new SSD and I wanted to at least make it usable even if that included wiping it.

Around 9:30 Friday evening I turned Cygnus on again and it booted. Not wanting to push my luck I turned it off again almost immediately, but not before I'd removed the password on the hard drive.

It turns out that password-locking a drive is a massively bad idea. Among other things it means that you can't use it in an external enclosure, and might not even be able to use it in another computer. It's better to use your OS's "whole-disk" encryption, because that actually encrypts everything but the boot partition, and it does so in a standardized way so that you can use it anywhere as long as you have the password. You can use a variant on the same encryption technique to encrypt a single home directory, or even a single subdirectory.

Also Sunday, I discovered when I went to post last week's summary that my client, ljupdate.el, doesn't work any more because Dreamwidth has gone to SSL everywhere. I made several attempts to fix it, but so far no joy. I'll probably have to cut-and-paste again. After I get my taxes in, the first thing I want to do is write a new -- and more general -- posting client and integrate it with my build system (see MakeStuff).

This Saturday, though, N went to the Seattle Home Show and found a company that was having a 2-for-1 deal on some pretty awesome scooters. They're not exactly travel scooters -- they fold a little but don't come apart, and they're pretty heavy, but they're designed to be roadworthy. 18mph with a 25-mile range. We'll probably have to replace the seat on one for Colleen to be comfortable, but... She can definitely ride to Freeland and back in one.

In all, a rather frustrating week, but it could have been a lot worse.

Notes & links, as usual )

mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

Note: posting from the web form because ljupdate can't do ssl :P

Hmm. I don't remember this as being a particularly bad week. Things must be going ok. Or ok-ish. Not to be confused with orcish. I don't think things have been orcish.

The main accomplishment for the week was getting my desk, a 2x4 slab of half-inch oak plywood, off of the two tray tables it had been sitting on and onto proper legs. The legs are 2x2s braced with angle brackets; I later added a 1x8 across the back to keep it from sagging. Unlike most desks, this one is meant to have me sitting on one of the short sides; this lets me put both printers on top and store two file pedestals or similar things underneath (though doing that will require clearing off a great deal of paperwork clutter).

Our sick kitten, Bronx, appears to be recovering. He's still thin, and we're on day four of the five-day period after his last dose of antibiotic during which his bacterial infection might come back, but so far so good. He's back to his usual rambunctious self, though. Finally.

Sunday we announced a music party and invited mostly the people we'd met at (neighbor) Dean's party a couple of weeks before. Nobody showed up -- we were only mildly disappointed and not at all surprised, but N and I had a good time singing. I have continued to spend a few minutes every day noodling, in hopes of getting my left-hand calluses back in shape. Set list in the notes.

Colleen's Samsung tablet is dead -- probably the power connector. Again. Even if that gets fixed, which will be worthwhile if only to do a factory reset, the battery life was down to 2 hours or so. To replace it, I ordered a 10.1" Lenovo Tab 4. Very nice. I'm thinking of ordering the 8" one for myself, to replace the Nexus 7 that disappeared. (It's probably in a box. Good luck finding it, since it wasn't in the bin I labeled for it.)

I've been approved to buy enough term life insurance to cover the mortgage. At the "healthy" rate, even! This is slightly mind-boggling. Now I have to figure out whether it's worth the money. I also have to finish my income tax; the deadline after the extension I filed is October 17th. Basically all that's left is tracking down the charitable deductions. I also need to put in something toward my estimated taxes because I haven't been withholding enough. Meaning I also have to track down and file the W4s.

Alongside that, I have to go through the exercise of preparing a reasonably accurate budget, based on my current cash flows. Which I should be able to get a pretty good handle on now that we've been here a while (and now that I've made the annual car insurance payment).

Colleen and I, at N's suggestion, have started making a weekly dinner menu. This coming week is the the first -- I'll report next week on how we did. The actual menu is at the bottom of the notes.

Notes & links, as usual )

mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

I'm taking a "vacation" -- actually a staycation with enough housework and other difficult tasks to make it more likely something I'll need to go back to work to relax from -- between now and next year. This last week was pretty relaxed at work; there was a group party on Monday, and I gave a short concert. Mostly funny computer songs, as one might expect.

We're doing the holidays a little differently this year, because N and her kids are out of town until Monday. So we had my kids yesterday, doing nothing in particular today, and doing the household celebration and gift exchange tomorrow. Boxing Day is traditional for that in some cultures, and besides it's Hanukkah, so that works anyway.

As part of the downsizing process I'm moving the household fileserver into a smaller case. I'll be going back to the Intel atom mini-ITX board, and I found the case I'd been looking for. It's just tall enough for two 3.5" hard drives, and two stacked card slots which I probably won't have much use for unless I decide to put the mirror drive in an eSATA box.

Emotionally (and it still seems odd to be writing that word, because alexithymia) it's been something of a roller coaster. A woman smiled at me and said hello on Tuesday; I noticed that I was unreasonably happy about that. Not sure why that seemed notable at the time, but it was. On the other hand I had a couple of severe anxiety attacks (or something -- all I'm really sure about are the physical effects). Actually, come to think of it, they often occur after I've been frightened, when whatever scared me has gone away. So there's that.

I'm constantly on edge, often irritated at nothing at all, and feel kind of -- is "fragile" the right word? Sometimes I scare people. I hate this.

I've gotten a little more used to the idea of retiring and moving, but I hate that too. These things are probably all connected, and connected to Trump as well. I guess it's good to have somebody to blame who's really evil enough to deserve it.

Have a happy Christmas, merry Hanukkah, or whatever else you're celebrating.

Notes & links, as usual )

mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

Moderately productive, though not as much as I needed to be. Story of my life, I guess.

Plans have firmed up: I am retiring next year; we are putting the house on the market in Spring, and moving to New England. We will probably buy a house there, unless things look so bad that we think we'll have to leave the country within the next year. I hate this. At least I can't blame myself for Trump and his gang. I can and do blame myself for the financial trainwreck. I was in denial for a loooooong time. We all were. I still am, to some extent.

Colleen, Giselle, and Naomi have done a lot of decluttering in the sewing corner, cubhouse, downstairs, and some of the books. It's a start. I've started, too, clearing off the clutter from the Great Room hearth, starting to sort through my boxes. I'm still attached to a lot of things; I need to be more ruthless. There are boxes and boxes of little things I never used, kept because there might be a use for them someday. Or that turned out to require more effort than I wanted to spend, and hung around until they were totally obsolete. (A lot of little Linux boxen in that category.) We still haven't started on the garage. For the second time, or is it the third?

Did I mention that I hate this? I hate this.

I've been having a little fun with the guitar I brought in to work last week. That, at least, has been ok. And my family is awesome. And we have cats.

Notes & links, as usual )

mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

Back to work after a nice but too-short staycation. I got a little over half of my list done, and a few more started; that's about what I expected. (The actual list is in the notes, between Sunday and Monday.) I also spent all day Saturday (see last week) reconfiguring my household server after some hard drive corruption. So Nova has been switched from Debian to Ubuntu, and is being used as both the file server and my main workstation. Which has some advantages.

The vacation definitely reduced my stress level, though I think I'm still way behind on things at work. That wasn't helped by my swapping my secondary oncall, originally scheduled for the second week in October. However, I found the memory leak that's been blocking one of our deployments for weeks, so I'm feeling fairly pleased with that.

The charging port on Colleen's tablet finally got to the point where no cable in the house was making good enough contact to reliably charge it; I ordered a new part and some tools. Then ordered more tools, because the kit I ordered didn't include decent spudgers. (I love that word!)

I'm still spending too much time on Quora. Their user interface continues to suck, though, and I gave up on cross-posting to Facebook because they insist on posting an irrelevant image with a picture of the first few words of the question, instead of actual text. Still cross-posting to Twitter, and getting a little feedback there, but I don't actually read Twitter so I don't much care what it looks like. I put links here in the notes when I write something I'm reasonably pleased with.

In spite of my expertise in programming, I find myself mostly answering dating and relationship questions. I figure that 40-odd years of marriage at least indicates some familiarity with the subject, and in most cases the answers are pretty obvious. "How do I know whether X likes me?" "You ask them." "What should I do after she (always she -- funny thing aout that) rejected me?" "Leave her alone and go look for somebody else." I also do it because many of the other answers I see are not only clueless but amount to recommending harassment.

I think the real reason I do it is that it counteracts my near-total lack of self-confidence in my social skills. Not that I can actually apply those "skills" in the field, of course. Not that I take my own advice and, um, practice. Oh. Right.

If you're looking for something fun to read, Lúthien: Tolkien’s Badass Elf Princess is a great retelling of "Beren and Lúthien in "Badass of the Week" style.

Notes & links, as usual )

mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

This post covers most of my week-long vacation, so while it's not quite time for a wrap-up of my goals, I can say that I met about half of them. Which was about what I expected.

The big accomplishment for the week, without a doubt, was posting my one-line Linux setup/configuration package up on GitHub. (I then spent much of the rest of the week debugging and tweaking, but that's also to be expected.) It's called Honu, after the Hawaiian name for the green sea turtle, because a turtle carries its home around with it. The README starts off with this quote from my song, Windward, because I just couldn't resist:

Where the wind takes us next year no turtle can tell
But we'll still be at home, come high water or hell,
Because home is wherever you carry your shell.

The implied puns on $HOME and sh(1) are, of course, entirely intentional.

Honu is meant to be fairly general; it's expected that any user -- including me! -- is going to want to customize the heck out of it. To that end, there's a sample customization package, also on GitHub, called Myrtle. Of course. (My own customization package, which you will not find on GitHub, is called Mathilda, after LookingGlass Folk's name for the narrator of "Windward".)

It hasn't been all roses and rainbows, however. I've spent an inordinate amount of time coping with the bindweed (morning glory's evil twin) that has overgrown the walkway along the south side of the house, sorting a year or two's worth of mail, and recovering from last week's disk crash on the server. I've been doing quite a lot of writing, though a lot of that has been on Quora, so I'm not sure whether that counts toward my daily writing goal, or away from it.

I'll say one thing for Quora, though -- it makes me appreciate my own knowledge and social skills. Being able to answer questions is a real boost to my self-confidence in both those areas. Who knew?

Psychologically, well, ... mixed. I've definitely been less stressed out the last two days of the week than the first two -- I was able to handle a trip downtown that turned out to be a total write-off, due to things being closed/not where I expected, quite calmly and even with a little wry humor. The check from last week's stock sale arrived on Tuesday, which helped. On the other hand, it still apparently doesn't take much frustration to put me back over the edge.

I was a total wreck on Sunday. I seem to handle stress a lot better when I'm by myself. With Colleen around, especially, I get into a horrible feedback loop. By the time I got home I could probably have used an Ativan, but my prescription on those has long since expired. I settled for reading and gin. Low blood sugar may have contributed; I'm not sure I can tell the difference between anxiety and hunger. Alexithymia in action.

I am not ready to go back to work tomorrow. I may never be ready. I'll do it, but it won't be pretty. Notes & links, as usual )

mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

Almost no writing this week, even counting LJ posts; I have, however, been spending time catching up with home software/ops-related tasks, so I'm going to count that as writing time, if not word count. A little more productive at work than two weeks ago, although I wasted a lot of time getting back to where I had been before a rebase.

Apart from that, though, things are going better at work than I expected them to. I'm getting things done at home, too -- notably, working with Glenn to bring Naomi's enormous new chair downstairs. Tight fit, but we did it. (It's either a huge chair or a smallish loveseat. Either way, it's gorgeous but at 32" just barely fit through the doors.)

Went out for sushi with Colleen, Rabbit, and Chaos, in honor of Chaos's 31st birthday. I'm too young to have a daughter in her thirties, right? Oh. Right.

The high point of the week, though, was going to the West Seattle Summerfest yesterday with Colleen and Naomi. Glenn on the way there, though he left early. Rather than try to load everyone into the van, hassle with parking, and load and unload the scooter, I simply made sure both scooters' batteries were charged, and we st/rolled. Fun.

There was a tiny house on display, from Seattle Tiny Homes -- the bathroom was awesome, with a walk-in tub, washer, and wall-mounted dryer. All in about 5x8 feet. We'll definitely be working with those people. Also with the solar power people. And in the more immediate future, Naomi found a builder that we might use for the basement water-damage repair.

We also bought some fun art prints. And Naomi insisted that I buy a hat, which she said fits me the way my leather jacket does; I can't say she's wrong about that. It's the 8-section style in tweed, but every section is a subtly different color and weave. Kind of awesome, actually.

I told N on the way back that it was the most fun I'd had in a long time; she said that was good, but it's unfortunate that I haven't been having more fun lately. Not sure what to do about that. I procrastinate, so I have a strong tendency to prioritize the more important things I'm not doing over the fun things I'm not doing. And figuring out what "fun" means is another problem -- I also have a tendency to dread doing things, especially new things, but to enjoy them after I get pushed into doing them. I think yesterday's expedition might have been an exception.

Westercon was not an exception -- I hadn't really expected to go, and expected it to be stressful. I enjoyed giving my concert, but hadn't expected to be doing that, either -- I only found out about it after I'd committed to going.

Notes & links, as usual )
mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

Not all that good a week. Continued lack of productivity at work, mainly because of meetings this time, but still... I want to take a vacation after Westercon, but I have goals that I can't meet if I do. Bletch.

I haven't done much writing, either. A reasonable amount on Monday, but only a little after that. Grump. Did do more cooking than usual: chicken tikka masala on Monday, and beef Stroganoff yesterday. That was a real win. Lots of shrooms. I note in passing that while Cash and Carry has great prices, it doesn't have a very big selection, and few if any small packages.

On the plus side, I did a pretty good job of noticing and identifying my mood Friday. On the minus side, the mood in question was despair. Cat therapy helps, but not completely.

A fair amount of computer-related work -- got my raspberry pi up and running, with both Raspbian and OSMC (on different cards). OSMC (Open Source Media Center) looks like it would work well as a music and video player. Being one of the original cards, it doesn't have much in the way of RAM, so it wouldn't work as a desktop with my current workload. I also swapped my desktop machine for one of the two that have been sitting behind my desk ever since we moved in.

Moderate amount of house-project work.

Notes & links, as usual )
mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

Moderately productive week. Lots of computer configuration and upgrading work, which is always an easy way for me to feel like I've done something, even if it isn't all that useful. I have a new desktop computer, in a nice little Shuttle box, but haven't fully switched over to it yet. Because browser tabs, mostly. (I also got the raspberry pi booting, finally. Which mostly required looking at the installed card and noticing that, not only did it not have an OS installed, but it wasn't flagged as bootable. The Pi is one of the original 512Mb ones -- it's dog slow. Still, it has a lot of potential as either a media center or a special-purpose controller. I'm guessing that used, older pi's are dirt cheap on eBay.

My new monitors arrived at work; I took advantage of the opportunity to re-arrange my workspace (see notes for 0615We) -- and to get back into writing, with xmonad as my first topic. Xmonad really wins for this, because the physical arrangement of the monitors becomes almost irrelevant. By moving the laptop in front of me (because it has a usable keyboard for once) with the dock under the monitor, I not only freed up a sizeable amount of desk space but freed up my second thinkpad keyboard to come home with me. Win.

Last weekend also included a lot of cleanup work in the garage and the back yard -- the huge piles of junk and lumber have been hauled away. I really hated to lose the lumber, but it had been out in the rain for too long. I was, however, able to save most of the hardwood.

As indicated, I have been writing (see notes for 0614Tu). My goal is to write 500 words most days. (I missed yesterday because I was hacking on my journaling makefiles, which sort of counts in terms of time if not bytes.) This post is intended to hit today's word count, and, no, I'm not going to count the notes.

So that raises a question for you, my loyal readers. The article I'm writing on xmonad isn't done yet, but I do have two days worth of work on it. Should I post "episodes" as I go along? Maybe I should phrase that differently -- would anyone object if I did post what amount to partial rough drafts? Feedback would be useful. Because otherwise, that's what I'm going to do.

Some other ongoing projects will also be included in the word count, notably "Songs for Saturday" (or occasionally Sunday, if I'm being lazy) and the "River" posts. I will find or create a tag for the Linux-related stuff, like the aforementioned xmonad article, and probably "adventures in home computing" as well. Fiction is somewhat unlikely; I'm pretty bad at it, especially plotting. Metafiction and prose poems are a distinct possibility, though.

There. 500 words. Approximately, since wc doesn't distinguish between actual content and markup. At some point I need to do something about that, but I'm not going to worry about it right now.

Notes & links, as usual )
mdlbear: (g15-meters)

I've gotten a lot done this week, at work but mostly at the house. We have a truck coming Wednesday to haul away the pile of junk that's been sitting in the back yard getting water-damaged since last year when we sorted through the stuff in the garage. This week I've been adding to it, and especially yesterday when I disassembled the pile of wood sitting on top of the old blue workbench. The latter, and most of the wood, were in sorry shape. It hurt a lot to see how bad they'd gotten. I did manage to save most of the hardwood and vertical-grain Douglas fir, so it wasn't a total loss, but close.

Well, we didn't really have room for the workbench, anyway.

I've also been through a couple of the boxes behind my desk. Including the one labeled "tiny computers". It seems that, over the years, I've spent an inordinate amount of money on small Linux-based devices that I mostly haven't taken the time to get working. There's a list in the notes, under 0611. And then there are the laptops (all but one of which have been recently upgraded to the latest Ubuntu, so that's good), the two Linux boxes in tower cases that are still perfectly functional, but I don't need them, the old Android tablets, ...

*sigh*

I've found other "treasures", too. I'm not sure nostalgia is good for me. Too many reminders of things I haven't done, or started but abandoned. It's easy to blame depression, and I do, but that doesn't make it any easier. Or less depressing.

I think it says something -- damned if I know what it says -- that while I noticed last Sunday that I had put in a good day's work and accomplished a lot, I didn't connect that fact with a feeling of accomplishment, or any other emotion. (If "accomplishment" even counts as an emotion. I think it does, but I'm not sure. That probably says something, too.)

Music note (see 0611 -- yesterday was busy, too): At the suggestion of the guy who sits next to me at work, I looked up the Demoscene and watched a couple of videos, and a documentary, on YouTube. Mind-blowing. Especially when you consider that, say, "Chaos Theory" by Conspiracy -- the whole thing, music and video -- was entirely generated by a 64K program in real time.

The demoscene reminds me a lot of the filk community, and it makes me want to see what could be done for World Inside the Crystal that way.

Notes & links, as usual )
mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

Not a great week psychologically, on the whole. Frazzled. Burned out? Probably. Lots of random, depressed-sounding self-talk, and practically everything I see or think about reminds me of something I've done wrong. In most cases the mistakes are unfixable, with drastic consequences. Doomed? That's how it feels. Doomed. (Cue Imperial March from Star Wars: doom doom doom doomty doom doomty doom...)

On the other hand, I've gotten almost all of the household computers -- at least, the ones that aren't G's -- upgraded with Ubuntu 16.04. It's a fast, easy install even on modern machines with secure boot, and my bootstrap script for setting up Gnome flashback, xmonad, and the other stuff I rely on is working pretty well now. I've also resurrected Kat's Acer Aspire (which I dubbed "aspie" because, while it's brilliant, it has trouble communicating -- took me forever to find the key combination that brings up the boot menu). And Emmy's Dell, which I'd thought had a broken charging port, turned out to just need a real Dell charger. :P

G is a professional system administrator -- he can do his own upgrades.

I also bought a new washer for downstairs. It arrives Tuesday, which means that this weekend's project is clearing a path to the downstairs laundry room. Also, most likely, putting up shelves in the garage and the downstairs closet, and curtain rods on N's door.

Yesterday's amusement -- high point of the week, actually -- was Ticia waking me up and teaching me how to play fetch. Really -- she batted her crinkle ball off the bed, picked it up and brought it back, batted it off again, brought it back, ... By that time I was awake and had gotten the hint, so I tossed it for her to fetch. Did that a couple of times. She doesn't usually bring the ball back to me, so I suspect that she thinks she invented the game all by herself. And so she did.

See also, xkcd: My Friend Catherine.

Notes & links, as usual )
mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

Kind of a rough week. My main accomplishments, such as they were, were a result of puttering around the house: finishing the third box of shredding from the garage, clearing out a couple of boxes from the cubhouse (and finding quite a lot of stuff that I'd been looking for), things like that. Progress at work, but not as much as I would have liked. Stress is not conducive to anything that requires concentration.

More stress than I would have liked, too, though things have gotten a lot better since Monday. I think I've managed to noodle on the guitar for at least a few minutes every day -- it seems to help.

QOTD: As affirmations go, "I have not yet failed" is probably never gonna compete with "All will be well and all will be well and all manner of things will be well" but some days it's the one that really resonates. -- Ursula Vernon. Maybe quote of the year.

Along the way I've upgraded a couple of laptops, and (I hope!) finished tweaking my xmonad window manager configuration. Most laptops in the house are now running Ubuntu 16.04; a few are still on 15.10. Upgrading laptops and tweaking config files isn't really productive, but it's somehow comforting and gives the illusion of productivity.

Notes & links, as usual )
mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

A good week for Sanders supporters. Last Sunday we went to the Bernie Sanders rally at Key Arena, and yesterday was the Democratic caucuses. (There was another rally Friday evening that G and N went to, but I didn't.) As you probably know, Bernie won big in all three of Washington, Alaska, and Hawaii yesterday.

The rally was amazing. He's an electrifying speaker, with a message that resonates deeply with this old radical's values. We need him in the White House.

This was the first time I've been in a caucus, and despite the reference in Alice it wasn't dry at all. Mostly fun, with some boring bits and too much standing.

Inspired by the Functional Programming Principles in Scala course that our team's reading group is taking, I have branched out into Haskell and started to set up xmonad, the tiling window manager that rocks. The main reason for that is the way it handles multiple monitors, which looks like a great match for the way I use my work laptop, always switching between stand-alone at meetings, and plugged into multiple monitors on my desktop.

Still trying to wrap my head around monads and category theory in functional programming. Multiple Wikipedia dives on that one.

Notes & links, as usual )
mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

It's only been two days since my last "done" post, but I wanted to finish off the month, and in any case it's been a fairly eventful couple of days.

Lots of Linux configuration stuff (and more today), much of it triggered by the hard drive to SSD upgrade I did on my laptop. Tweaking is still ongoing, but mostly it's done (for example, I'm posting from it). And Sunday I nailed a configuration problem (having to do with locales, but showing up only as inability to start gnome-terminal over ssh). Fun!

Yesterday had been set aside at work for doing or learning something new. I spent the day learning the Go programming language. It has a lot to recommend it: fast as a bat, first class functions, real closures, duck-typed interfaces, coroutines and channels, documentation done right (i.e. simple, ordinary comments). A few things to dislike, but I'm likely to try some small projects in it.

I could still have gotten more done. Notes & links, as usual )

mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

Productive? Got a fair amount done at work, and finally went ahead and bought a solid-state drive for (laptop) Cygnus. And spent almost all day yesterday installing and configuring it. In preparation for the upcoming Ubuntu 16.04 LTS release, I installed 15.10. Naturally, a lot of things broke. Boots faster, but what I was really looking for was the self-encrypting feature.

Interestingly, you can't even get into the BIOS or boot from an external drive without giving the disk password. That's good, if occasionally annoying.

In other news, the Younger Daughter has moved out of the house, and in with her boyfriend. That feels indescribably weird. With N's kids still in the house, it's not exactly an empty nest, but... weird.

We have an extra room upstairs now.

Notes & links, as usual )
mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

I haz apparently been a Productive Bear, at least some of the time. I finally got around to putting grout into the seam where the arch was cut in between the kitchen and the Rainbow Room, and I now have a fourth working UPS and a functioning git-based web deployment system (for everything but the audio files, of course).

On the other hand, we had a one-hour power outage last night that revealed the fact that the server was plugged into the surge protector outlet on one of those UPSs instead of a battery-backed-up outlet. *headdesk*

I transferred my stuff from the shoulder bag I've been using for the last couple of years, to a rolling backpack. Which is clumsy as heck, but more comfortable to use. The major win, though, was putting my wallet and a couple of other essentials into a little shoulder bag (Eagle Creek Sidekick) so that I can just grab that and go out to lunch, or shopping with Colleen. Major win -- it's practically weightless by comparison with the old one. Of course, it can't carry a laptop, cane, rain hat, phone backup battery, coin purse, ... -- which is all rather the point of the exercise.

I have also been coming home hurting, and emotionally fragile from depression and anxiety. So there's that.

On the whole, though, not too bad of a week. I'll take it. Links in the notes as usual.

raw notes, with links )
mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

So. A reasonably productive week, at least at home, where I've been cleaning up my server so that I can use git for most deployments and backup, instead of my clunky old rsync system (which worked pretty damned well, but a large USB hard drive represents a pretty big single point of failure, and it did). That doesn't keep me from doing a nightly mirror, but I'll be relying on git for history.

In the process, I wrote the website deployment git hook and make targets, so I can say "make deploy" on my laptop and have the changes checked in, pushed to the server, and pulled onto the web host with no further interaction.

There are still some remaining tasks around asset management, since my audio files are way too big to be flinging around with git.

At work... not so much. I feel as though I'm not being as productive as I should be.

Also on the down side, I managed to tweak my left QL muscle getting into a car on Wednesday. Naomi managed to get it mostly relaxed, but says that I have to start acting my age and learn to move like an old man instead of assuming that my body will just do what I tell it to. Grump.

And we nearly lost our ninja cat, Desti, who snuck out an insufficiently-closed door. She was, of course, wet and miserable and scared, but that probably won't keep her from trying to sneak out. Because ninja cat.

Oh, and two of Colleen's three lift chairs are broken. She's going to have a repair person come out this week. Fortunately the chairs, her power wheelchairs, and her scooter (which also need attention) are all made by Pride, so she can get them all looked at at once.

To end on a high note, and a link, we saw a preview of the first two episodes of the HBO/American Museum of Natural History mini-series Saving My Tomorrow, about young environmental activists. N's kids were interviewed for it, although they didn't appear in the episodes we saw.

More links in the notes, of course.

raw notes, with links )
mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

A bit of a rough week, but with several high spots. The first of which was brunch with Colleen and Emmy at Salty's -- a local seafood place with a fantastic buffet on weekends. Turns out I get a senior discount. :P

I am cautiously optimistic about my mood, between selling the house and starting on l-tryptophan. I think it's generally better, but it's also more volatile -- I run out of cope and go into overload. Not good. Especially because it upsets Colleen, which sets up a positive feedback loop. (Positive in the feedback sense -- it has negative consequences, of course.)

Another high point was music night, Thursday after dinner. The original plan had been for a new friend of N's to come join us, but she ended up canceling. We had fun anyway -- playlist in the notes. We've decided to do it more often, and N is setting things up to spend more time in the Great Room. Which means I have to fix the control on the broken lift chair that we parked there.

To which end I tracked down a soldering iron. The one I bought because I couldn't find my good one, which is still in a box somewhere.

Looking at the notes, I seem to have been pretty productive this week. So... ok.

raw notes, with links )
mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

Kind of a rough week? I'm not really sure.

On the plus side, we got the washer repaired (a little over $320 for a new drain pump), and I switched the network over from Comcast to CenturyLink. Which was exactly as easy as I expected it to be: swap the router and the extension WAP, and it's done. Sometime I should swap SSIDs back, but it doesn't matter all that much much.

Our group moved over the weekend; the move puts us in the center of $A's main campus (with a nice small caffeteria next door, and the main one only a block away). My hard drive didn't survive it. All my code was backed up, but that still left a huge amount of configuration that should have been but wasn't. Fixed now.

Tapered off my antidepressant. Not much of an effect on my mood; not clear whether it has affected my supply of cope or my weight.

Kind of late, but I've started practicing for Orycon. Not entirely clear what's going into my set -- Millennium's Dawn, Keep the Dream Alive, and QV for sure. That may actually be almost enough, since it's only a half-hour set.

raw notes, with links )
mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

A couple of dizzy spells, which felt a lot like a return of the orthostatic hypotension I used to get rather frequently before I changed my blood pressure meds, only more severe. Turns out that they could be exactly that, as a side effect of cutting down on my SSRI antidepressant.

Worked from home Friday and half of Thursday due to our office move. Spent Monday (and will probably spend most of today) setting up my desktop box, whose hard drive didn't survive the move. :P Grumble. Only things I'll actually be losing are a couple of little scripts in ~/bin, my .zshrc customizations, and my browser config. Everything else is in git.

Stupidly tried to upgrade the OS on my laptop. Stupid, because it left it practically unusable. A clean reinstall of 14.04 fared better, but there are still some oddities here and there.

Working from home today, too, because I'll be waiting for the washer to get repaired. :P It broke on Saturday. The backup drive on Nova has apparently been broken for a *long* time -- read is ok, but write fails. This may be a timing thing, but switching it from USB to eSATA renumbers the drive letters, so that's kind of a non-starter.

On the positive side, the CenturyLink internet connection is on, and the new modem arrived yesterday. Hopefully today I'll be able to get our network configured -- it may be a simple matter of swapping two routers.

The new building is significantly farther away from the bus stop -- there are closer ones, but it's actually faster to walk than to wait for a transfer. So if it's not raining, I'll do that.

Kind of a rough week. Oddly, the fact that I've cut back on my antidepressant doesn't seem to have made much difference that I can perceive, which says that either it wasn't doing much good, or I'm still bad at detecting my mood. Or both.

raw notes, with links )
mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)
There's that moment when everything changes,
But really it's just you,
Seeing things differently.

When you realize that the solid bench you're sitting on
Is mostly empty space between particles.
When you learn that even the particles
Aren't really particles, and that light isn't entirely waves either.

When you see the way special relativity views velocity
As simple rotation in four-space, 
And you study general relativity and realize
That it's geometry all the way down.

When you suddenly get recursion,
Reading the Algol 60 Report, with its crystalline prose
And elegantly compact rules.
When Goedel blows the top of your head off,
And you understand that some things simply can't be proved.
When you see how elegantly Turing applies the same trick.

When you realize that a little of the Unknowable
Isn't part of the Unknown anymore,
Because now you know why you can't know it.

First published in a comment in the October 2014 Crowdfunding Creative Jam, on the theme "Paradigm Shifting Without a Clutch."

This is entirely autobiographical, though the sequence has been messed with a little to give artistic verisimilitude to an otherwise bald and unconvincing narrative.

Mirrored from steve.savitzky.net. My poetry there is in really rough shape; hopefully I'll get a little work done on it soon.

Also adopted by [personal profile] ysabetwordsmith as part of her Schrodinger's Heroes series, which makes it unintentionally canonical fanfic for an imaginary TV show. Talk about shifting without a clutch! At least it has synchromesh. Or was that synchrotron?

mdlbear: a locomotive engine dangling from a hole in a building (trainwreck)

Not such a good week. Productive, but not fun.

I did have some good times with Colleen, going for a drive last Sunday, and to the Northwest Tea Festival yesterday. Colleen's favorite vendor, Silk Road, was a no-show, so she used the money she didn't spend there to buy us lunch. A really great outing.

I spent last Sunday updating old laptops -- they're all old and the ones capable of running Windows 7 really suck at it, but they all make good Linux boxes. I spent the rest of the day working my way through the piles of accumulated bills. Yesterday I spent the evening switching online accounts off of credit cards and onto debit cards.

Today I'll tackle the medical bills, which I've been ignoring for way too long.

Naomi pointed out, rather sharply, that my biggest problem isn't being stupid (though I've done a lot of that), but my habit of ignoring the hard stuff and hoping it will go away. Which, of course, is massively stupid, since ignoring things like that only makes them progressively worse. Which makes them harder to face. And so on.

This is what's called a vicious circle. With BIG SHARP TEETH. I think I need an icon for that.

Oddly, the fact that I've cut back on my antidepressant doesn't seem to have made much of a difference. This leads me to suspect that I should drop the SSRI altogether and switch to something with a different mechanism. Possibly tryptophan.

Links, as usual, in the notes.

raw notes, with links )
mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

(This bit of nonfiction is being written in response to recent events; it also seems to fit the "communication" part of the theme, "Community & Communication", of this month's Crowdfunding Creative Jam)

Someone died recently and left his widow with a problem: his computer's hard drive is encrypted, and he didn't leave the recovery key or his password anywhere that she can find.

Oops.

This is not unlike losing track of the key to the safe deposit box, forgetting the combination to the safe, or neglecting to make out a will. "But I have all that in a file on my computer!" I hear you cry.

Oh, right.

You need a JustIn Case file, someplace where it's safe but reasonably easy to find if anything happens to you. (I'm talking to myself here, too, by the way.) The bare minimum is whatever it takes to get into your computer (a FileVault recovery key, BitLocker PIN, or alternate admin password) and possibly into your password file, browser keychain, or whatever. *That* information needs to be in a couple of different places known to your family! At least one place should be outside your house, e.g. with a trusted relative, your lawyer, your safe deposit box, or the like. The other place should be in your house, e.g. in a locked filing cabinet (they're pretty easy to break into if necessary). Lable the file "Justin Case".

Even if almost everything is on your hard drive, there's a minimum set of things that have to be written down on hardcopy:

  • Your master password, recovery key, or whatever it takes to get into your data. Or at least all of your data that you don't want effectively burned when you're gone. (Keep that separate.)
  • The location of your will, safe deposit box, offsite backups, retirement and bank accounts, life insurance policies, and so on.
  • The name of your executor/executrix.
  • Any important information that your family is likely to need

My plan is to add an SD card with my most important files on it -- I checked, and the directory with all my passwords, tax information, receipts, and so on is only about 200MB. Perfect use for an old 500MB card or thumb drive that's too small to be useful for anything else.

Don't forget to update it if you change your password! That, after all, is the main point of this little exercise.

mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

Oh. Right. I started working on this an hour or so ago and got distracted when my Mom called. So.

Last Monday was our return from Consonance -- I'd booked the latest flight, which allowed us to do some visiting and talk with the realtor. It seems many people are sad about losing the Starport -- it has, after all, been a fannish landmark for over three decades. *sigh* Keeping two houses just isn't feasible. I just hope the proceeds are enough to cover the new construction.

Naomi's friend Rika flew up with her and spent the week; we had quite a lot of music at the house, and visitors most nights. No complaints from me! The week ended with Colleen's birthday party yesterday. We still haven't built up a good list for these things; we'll have to work on that. Also a household calendar and mailing list -- probably means I have an excuse to learn Wordpress, or something like it.

Yesterday, along with the party, I installed a pair of powerline ethernet dongles. Took me forever to do it, partly because the house has two breaker boxes (meaning there are outlets that can't talk to one another), and partly because I misunderstood how the "sync" button works. It really means "rotate keys", not "synchronize" :P. The extension router is now installed in the coffee niche.

The gadgets are advertised as "500MHz", but only have 100MHz ethernet; 500 must be the aggregate across all nodes in the network. We definitely need to install some cable. *sigh*

raw notes, with links )
mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

The main event this last week was, of course, Consonance . Fun! I signed Lookingglass Folk up for a 2x10 on Sunday, along with international guest Rika Koerte, who is one of N's dearest friends. We sang "Lord Of the Buffalo" -- we'd been planning to sing The Fox as well, but the sound crew had an incredible amount of trouble setting us up. No idea why.

I also got a surprise 2x10 slot on Saturday, because they were short on sign-ups. Did a quick solo of "Bigger On the Inside" (with an extra Rainbow's End verse scribbled down during the previous two songs) and "Wheelin'".

Both sets were well-received. I also had a long conversation/song-swap with a guy named Ashton (no relation to the UXBF), a Mills College grad student working on a paper on filk as an oral tradition. Many songs, including QV, Ship of Stone, World Inside the Crystal, and Keep the Dream Alive. Others.

I re-packed for the trip, going from the JanSport backpack/shoulder bag (itself a re-pack from the old REI shoulder bag) to the new rolling backpack that I picked up a few weeks ago. Both modes proved extremely useful. A couple of things didn't get packed, though, including a small power strip, which would have been handy in the airport.

The con was back in the Milpitas Crowne Plaza (which calls itself the San Jose/Silicon Valley CP, because who's heard of Milpitas); recently remodeled. The changes are mostly a win -- there are more power outlets in the lobby, and our (accessible) room had a door that opens outward, which is a major win. The toilet, not so much, and the bed was as usual way too high for Colleen. Wait staff spread seriously thin.

Anyway, good con.

We also met with our realtor -- the Starport should officially go on the market sometime around the end of May.

I also got my WiFi extension hooked up, via a dumb travel router; it has a bridge mode, but won't connect to a secured network in that mode. I promptly ordered a set of high-speed power-line Ethernet interfaces, but haven't set them up yet because they don't work through surge suppressors. Which we have on both ends, because electronics.

  • The other small router, the DIR-505, would have worked better except its receiver sucks -- it couldn't make a connection with either of our access points, despite the fact that my laptop had no problems only 2m away. :P
  • raw notes, with links )
    mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

    Not a whole lot going on last week. I installed a new main drive on nova; it's still not fully configured because I'm lazy, but at least it's running. And able to boot. Because I'd installed a SATA card, which I discovered that my motherboard wouldn't boot from. :P Ended up putting the optical drive on it.

    I don't seem to post much, if anything, on work days. This says something about work/life balance. Or work/internet balance, which may or may not be the same thing.

    Loads of links.

    raw notes )
    mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

    Short one this time, because I want to wrap up the year. We had a power outage Monday that apparently hosed my server -- again. Not happy about that. I am happy about fixing both our non-sucking vacuum cleaners by the simple expedient of cleaning their filters.

    So, Happy New Year, and here's hoping it's a good one for all of us.

    Links in the notes, as usual.

    raw notes )

    Tha' Tha' That's all, folks. Welcome to 2014.

    mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

    Or anyway, the last ten days of last month. I finally got around to doing some much-needed maintenance on the computers and their configuration... and figured out why the UPS kept turning itself off -- it must have been doing its periodic battery test... on a totally dead battery. :P

    I also got the backup scripts back in operation. I now have a complete, almost-ready-to-boot mirror drive as well as my traditional incremental backup. What, me paranoid?

    The Shuttle box I've been using as a desktop system is dead; it runs for a few minutes, then kernel panics. Possibly memory. Not going to worry about it; it's had a good run. I seem to be doing ok with just the netbook for most purposes.

    Colleen's caregiver turned in her resignation on Monday, after leaving early Saturday for a family emergency, and not showing up at all on Monday. That's ok; today was going to have been her last day anyway. We've doubled Emmy's allowance.

    The YD is just as good a caregiver as May was, and more concerned with cooking things the whole household would like to eat. I'll miss the occasional spicy dish, but that's what sriracha's for.

    Colleen is mostly doing better, gradually getting her strength back. The YD is more willing to be firm with her about exercise than May was, so that's a plus, too. Of course she did spend the week with a fever of 102, not eating, and ended up spending most of the weekend in the hospital. (With a UTI, low blood pressure, dehydration, and messed-up blood chemistry.) She's better now, as I said.

    The LG washer/dryer combo arrived last Saturday; they couldn't actually install it because there wasn't a 110V outlet within reach. Got that taken care of, and finished the install myself. Not as tight against the wall as it should be, but it'll do. It's nice to have the extra laundry capacity.

    Somebody, probably May, didn't close the door to the deck firmly enough, and it blew open. Naturally, out little cat burgler found it and went outside. She hadn't gone far, though; after I tracked her down Naomi coaxed her back inside, looking wet and bedraggled. I doubt she's learned anything from her little adventure, though.

    Oh, and the idiot Republicans let the government go into shutdown. Again. The problem with coming up with a string of lies aimed at getting stupid people to vote the way you want, is that eventually they end up voting in stupid people who believe the lies. Oops. Did I mention idiots?

    Links in the notes.

    raw notes )
    mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

    Well, I have Nova (the file server) back online, though not fully configured. I also reconfigured the network, adding another WAP. This lets me drop the main SSID, rainbows-end, down to 802-11G. Trying to run G and N on the same network turns out to be a serious mistake. I resurrected the Netgear WNR3500L from Starport for the purpose, so it's running rainbows-end-N and functioning and providing 4 ethernet ports over in the desk area.

    Meanwhile, Colleen is making progress -- she gets into her power chair on a regular basis, though she's still not too good at unassisted transfers.

    Desti, our little feline escape artist, managed to let herself out onto the roof via the bathroom window, which was open because the mis-drilled holes in the tub had been repaired, and the workman hadn't bothered to close the door. I know, it's expecting a lot, and my little bear-like brain kept thinking up ways to make it my fault, including not remembering to mention the possibility to Naomi, and not having cat-proofed the door to Naomi's bedroom. Desti had, in fact, been put in there, but she was out the door before Naomi could get across the room to stop her.

    Fortunately, "The Cat Came Back, the very next day" -- Curio stood on the kitchen counter meowing out the window, and I heard an answer. Opened the front door and there she was. She was very clingy for the next day or so.

    Think she's learned not to leave the house? Nawwww. Not likely.

    We also had our new instant hot water tap installed. But it didn't work. Spent about an hour tracing tubes and verifying the installation before finally figuring out that it was plugged into the same outlet as the garbage disposal. Both outlets are swtched. :P

    We'll have to have an electrician out to re-wire it; it's not a job I feel like tackling myself. While he's here he can install a 110V outlet upstairs in the closet -- the washer-drier combo doesn't take 220. Naturally, nobody sells an adapter. :P

    A good collection of links in the notes, as usual.

    raw notes )
    mdlbear: the positively imaginary half of a cubic mandelbrot set (Default)

    Tried to log in on my file server last week and found out that the hard drive was dead. Finally went to Fry's yesterday, and bought a couple of Western Digital red (NAS) 2TB drives. Designed for continuous duty, which would be a good thing. Disassembled the lock on the docking bay I had the backup drive in (and promptly found the key, lurking in what had been my nightstand).

    Confirmed that the backup works and the old main drive doesn't, and installed the latest Debian. Which only took about an hour. It boots fast as a bat, and ships with a driver for the Realtek ethernet controller on my motherboard. So I can free up the PCI slot for something more useful, like maybe an ESATA/USB-3 card, if I can find one.

    Now begins the tedious process of restoring (done, as of this evening) and reconfiguring. Which will take time because I want to make some long-overdue changes in the config.

    It looks like the last time a backup was made was June 25th. I don't *think* I did much, if anything, since then except maybe add a couple of passwords to the keychain. And of course I've lost a lot of email. If you sent anything to steve at thestarport.org in the last couple of months, I haven't seen it. (It is now forwarded to my gmail account, along with steve at savitzky.net which I've been doing pretty well at keeping up with.)

    It's possible that some of the transient stuff can be rescued from the old drive -- it seems to run ok for a few minutes before suddenly going offline. Not entirely clear that it's worth bothering with.

    Apart from that... Colleen has been getting physical therapy three times/week, and is now able to stand up and transfer into her power chair. Progress. Her caregiver is an excellent cook -- Thai, Chinese, and Japanese, with an emphasis on lean and low sodium. Yum!

    Links in the notes, as usual. One, found by a coworker after I'd mentioned something to that effect, is one of my favorite stats: iPad 2 as fast as Cray 2 supercomputer. I also dropped a donation on YsabetWordsmith's poem, "Part of Who I Am". Some great links there, too.

    raw notes )

    Most Popular Tags

    Syndicate

    RSS Atom

    Style Credit

    Page generated 2019-04-23 02:01 am
    Powered by Dreamwidth Studios