February 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 2019

Page Summary

Expand Cut Tags

No cut tags
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: 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)

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: (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)

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: (technonerdmonster)

A few months ago while waiting for a ferry with my sister I mentioned a programming language called Elm, which I've been particularly interested in because it's a functional language that compiles into Javascript. Her response, predictably, was something like "I have no idea what you just said. What does 'compiles' mean?" So I explained the difference between compilers and interpreters, and a few other things about programming languages, and she said that it was the first time anyone had explained how programming languages work in a way that made sense to her. In the back of my mind, I thought it might someday make an interesting blog post. So here it is.

Inside of a computer, everything is a number. These days, these numbers are all represented in binary (base two -- just ones and zeroes), stored in a couple of billion numbered locations each of which holds eight binary digits. (A binary digit is called a "bit", and eight of them together make a "byte", which is the amount of data needed to represent a number between 0 and 255, or a single character in a block of text. Apart from the numerical coincidence, computer bits have nothing to do with the bits that were made by breaking apart "pieces of eight".)

The numbers in the computer's memory are used for three different things. First, some of them are used to represent the data that the computer is going to be working on. Second, some of them represent the location of those data. And finally, some of them are instructions that tell the computer what to do with the data. Those instructions are called "machine language" because they're the only thing the machine actually understands. Nobody writes programs in machine language if they can possibly avoid it.

the details )

TL;DR: an assembler turns each line in a program directly into a machine-language instruction. A compiler takes a program written in a more complicated (for the computer) but easier to write in (for people) and turns it into a sequence of machine-language instructions, that can then be read back in and run. An interpreter skips that last step -- instead of writing out the machine language instructions, it just does them on the spot.

Teaser: Next time I'll talk about different kinds of programming languages: functional, imperative, object-oriented, and scripting. I'm also open to suggestions -- what would you like me to write about?

mdlbear: (technonerdmonster)

It's time to do a little planning. As you may remember from the previous post in this series, there are some projects I want to work on. (I also need to find a job, but that's a not completely separate issue. If anyone needs an expert Java programmer or a git expert, let me know.) The ones I want to concentrate on today are the apps, specifically the checklist app and the setlist app. The first major decision about each of them is which framework to base them on.

I really want to learn both React (with React Native on the back end), and Elm (with Electron on the back end), and I think it makes the most sense to write -- or at least start -- the checklist app first, and use React for it.

Here's my reasoning:

  1. React: React is by far the more popular of the two frameworks, so a lot of jobs ask for React experience. One reason it's more popular is that it's basically just a Javascript library -- programs look like Javascript with a little bit of HTML and HTML-like tags embedded in it. It's easy to learn (not that that's really a problem for me -- see below), and there are a lot of starter kits and tutorials around.
  2. Checklist app: It's pretty clear that the Checklist app will have a much wider audience, so it makes sense to do that first. It will also be easier to monetize (possibly as a freemium app, with the free version stand-alone and the premium version tied to a back-end service).
  3. The Setlist app, which includes a lyrics viewer and playlist generator as well, is likely to start out using my rather unusual music toolchain, and would actually be more useful (and get a lot more traffic) as a front end to the lookingglassfolk.com and steve.savitzky.net Song pages. It makes sense for it to start out as part of a website rather than as a stand-alone app.
  4. Elm is a pure functional language (I love functional languages, which is why it would be easy for me) that is closer to Haskell than to Javascript.

Next steps:

  1. Make a place in my working tree for projects. Try not to give in to the temptation to completely refactor the whole hierarchy.
  2. Pull down and install a React starter kit and some kind of Elm starter kit.
  3. Set up the projects' git repos and working trees.

Projects!

2018-04-13 06:26 am
mdlbear: (technonerdmonster)

It's been just short of a year since I retired, and I don't have a whole lot to show for it in the way of programming, apart from a little work on MakeStuff. OK, a fair amount. And it has an actual user now. But still.

Somewhere around the New Year I started making a(nother) list of potential projects that I wanted to work on in my retirement. As these things do, it got out of hand -- at last count there were 86 unfinished items in it. Time to start something.

There are a few constraints. I can't start any of the woodworking projects yet, because the contents of the garage are in storage waiting for the remodeling to get finished; that includes all of the woodworking tools. So there's that. Same for the recording projects -- my good microphones have either been boxed, or vanished altogether in the last move.

More than half the "projects" on the list are ideas for articles or blog posts -- there are forty or so of those. I should start picking them off, one or two every week, but they're not really projects.

What remains is mostly software: programs (the young people call them "apps" these days) and work on my websites. These are also areas where I have a lot to learn, and where I can develop skills that will be useful if I want -- or need -- to do some consulting. And there's another factor: there's really no difference between a web app and a mobile app! Not any more: with React Native and Electron, one can now build stand-alone cross-platform applications using web front-end frameworks -- they basically bundle a stripped-down browser and a trivial server with your web"site", which is often just a Single-Page Application (SPA). And with languages like Elm that compile into Javascript,...

I can haz apps

One app I want to write will be for managing checklists. (There's an existing app called Checkmate -- my first choice for a name; grumble -- that looks worth mining for ideas.) Beyond being able to have multiple, named lists, I want timing information so that one can ask questions like "how long ago did I last take my pain medication, and is it safe to take another dose?" That needs to work for both scheduled items, and "as-needed", floating items that can start their timer going at any time. More like a combination checklist and reminder system. I'd also like to be able to track the time it takes to go through a checklist, both so that I know when to start if I'm getting ready for something, and so that I know how much I'm improving with practice. Eventually it would be nice to link this to both a website and an Alexa skill -- the website will be easy, since almost the entire app will be usable as the front end.

It would be nice to have a combined lyrics viewer and a setlist planner. (I used to have a setlist planner, but it was in Perl and kept its state in the HTTP query string - bad news for caching and sort of search-engine pessimization.) There would be some overlap with the checklist app, since they both involve going through a list of things in sequence, with associated times. It would be especially useful on a tablet for performances, but it would be most effective combined with a website that hosts lyrics and music, which brings us to...

What a mangled web

Another thing I've been looking at is "Responsive Web Design" -- making websites that adjust smoothly between tiny mobile devices and large-screen desktops. This has long been a design requirement of mine anyway -- almost all my sites do this, but they do it by simply not having much of a layout, and they look bad both on very large screens and very small ones. It's time to take this to the next level by adding responsive CSS and mobile.

There are several websites that need work: lookingglassfolk.com, steve.savitzky.net, Stephen.Savitzky.net, and hyperspace-express.com at least. The first one is by far the simplest; just songs, concerts, (proposed) albums, and a gig schedule. steve.savitzky.net adds writing and software projects, but there's still a lot of overlap.

It would make sense to do the others using different responsive design frameworks, just to get experience with a few of the options. Stephen.Savitzky.net, in particular, is my "portfolio" site; it's also the only one that has a sidebar at the moment. It might be a good idea to turn into a GitHub Pages site. hyperspace-express.com is my "commercial" site, and it would make sense to use a CMS like Joomla or Drupal for it.

(I have some other sites, e.g. rainbows-end.net and thestarport.org, but they're simple enough to simply copy the CSS from one of the others. The Interesting.Places sub-site would be worth some attention.)

Now, here's my plan...

The underlying reason for picking this particular set of projects is to market myself as a blogger, consultant, and developer, in hopes of making a little money on the side. That suggests that I should start with the checklist app, and probably start the site makeovers by moving Stephen.Savitzky.net to a GitHub site (which would give me an obvious home for projects like MakeStuff and my development-focussed blogging). On the other hand, making over steve.savitzky.net would probably teach me more about responsive design, especially if I make S.S.net into a GitHub site. It might make more sense to keep S.S.net as a separate site, and build the GitHub site from scratch.

In any case, my main blogging site will remain here on Dreamwidth; most likely I'll just cross-post development-related blog entries to S.S.net (and GitHub, if it's separate). Or would it make more sense to keep all of the blogging concentrated here?

Comments? Ideas? Suggestions? Over to you folks.

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

Got a few things done; a little guitar (in 5-minute noodles, but still -- I need to get my fingers back in shape) and a little hacking (kludged together a script for posting to DW from Emacs, using a bash front end to charm, which seems to be the only available command-line client. I can do better, but this was good enough for last week's post, and this week's). I also figured out why ljupdate.el is still broken: it's using an HTTP GET macro that doesn't handle https. :P

I've brought up over half of our CDs, and gotten most of them onto shelves. The new organzation, subject to minor revisions, is:

  • Filk/folk/rock/pop/etc. alphabetical by performer. Last name for people.
  • Filk/folk/rock/pop/etc. collections, alphabetical by title.
  • Classical alphabetical by composer. Special exception for Gilbert & Sullivan, filed under G.
  • Classical collections, alphabetical by performer or title, whichever makes more sense.
  • Jazz, alphabetical by performer.
  • Show tunes and operas, alphabetical by title.
  • Natural sounds, relaxation, ambient, etc. alphabetical by title.
  • Christmas music, alphabetical by performer.

The household coined two new words: "rambronxious" (portmanteau, me) and "rambrooxious" (portmanteau, N). These join "rambunct" (back-formation) as a verb. We (finally) have our fridge's icemaker working. The thing was apparently wrecked by having been left to freeze, sometime before 2015 when the house was installed. (What's the right verb for a manufactured home? Not "built", certainly. "Manufactured", maybe.)

Not nearly as productive on the psych front -- the LCSW I contacted last week isn't taking new clients. And there are only a handful of therapists on the island who take Medicare. (No surprise, especially to those following siderea.) So I got stuck, as I usually do.

I did, however have an Insight(TM), which is that I'm still nowhere near recovered from two years of burnout at Amazon. (Below you will find a few links for burnout recovery. Helpful, but not excessively so.) I also started using my happy light. (Yeah; it's a SAD light -- "happy light" is the brand.) And Ticia has been exceptionally cuddly, which is nice.

And one more insight: I figured out why I don't like writing in Markdown or other text formats, and prefer LaTeX or HTML: they're basically physical markup, not semantic markup. In HTML I can, for example, distinguish between a citation and emphasis, even though they both get shown as italics. Given my current set of emacs bindings, HTML is easier for most things; songs and poems are easier in LaTeX with my FlkTeX macros.

Notes & links, as usual )

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

I spent pretty much the whole week, during "working hours" anyway, working on a project that's been on my queue for years: getting my lyrics to print two-sided and ensuring that if songs occupy two pages that they span an even-odd two page spread. It's working, as of this afternoon.

There are a couple of subtleties. Notably, if you're just printing a whole bound songbook, you don't care which side of the page a one-page song goes on. If you're printing individual songs to go into a looseleaf binder, on the other hand, you need a cover sheet on the first (right-hand) page to force both pages of a two-page song onto the correct page. And of course if you're printing lyrics to go on a song's web page, you don't want the cover page. But I have it working.

I also got Father's Day calls from both of my kids, got the keys to the new house (in a little party Monday afternoon), scheduled our move out of the apartment (for Wednesday July 12th, which will give us a little time to pack), got in contact with the various utility companies, and, ... I'm not sure there was much else. That's probably enough.

I still have the persistent feeling of not getting much done, and I'm constantly appalled at how much has to be done before we can move into the new place, and how little time we have. I'm still scared about how little money we have, and worried about the amount of stuff we still have to do to the new house to make it work for our family.

Not to mention whether we'll have anything at all left after Trump and his goons get through destroying our social safety net, not to mention the planet.

And speaking of global warming, it's in the 90s this week. For Seattle, that's scorching.

Notes & links, as usual )

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

It's been another rough week. This week it's been mostly health care -- I found out Tuesday that Amazon hadn't continued my health care as they said they were going to, so I was unable to order Colleen's humira. (Which, at $1800 for two doses, isn't something one wants to pay for out of pocket.) My HR contact is looking into it, but it took several days to get through; meanwhile I went online and signed up for Medicare Part D and identified a Medigap provider (ExpressScripts and Premera Blue Cross; both for continuity and because they seem to get top reviews. Who knows how long that will last under Trump(Doesn't)Care.)

I know there's something called compassion fatigue. Is despair fatigue a thing? Or is that just another phase of despair? I find myself incapable of being surprised at whatever outrageous thing Trump and the "Republicans" have done each day. (I put "Republicans" in quotes because they are rapidly turning this country into a right-wing dictatorship. I feel powerless to stop them.)

Onward. Had a really good trip with Colleen up to Whidbey Island; we went up the whole length of it and came back by way of Deception Pass. It's been a very long time since Colleen and I went out for a drive that long that was just a drive -- our occasional loop drives along the California coast were probably the last ones. It was a little too long, but it went ok.

I've been spending much of my spare time catching up on my reading. For some reason I'd stopped reading LWN (Linux Weekly News) sometime around the first of the year; in the last two weeks I've completely caught up. You can see the results in the links, most of which came from LWN, or indirectly by way of Sacha Chua's awesome Emacs News. I've also been finding Whidbey-related links. At some point I need to go back through my to.do archives, extract all the links, and aggregate them. They're kind of useless scattered across blog entries the way they are.

I've even done a little walking (not quite every day, and not much because I seem to be walking at about half my old 3mph pace), a little music, and a little hacking (almost entirely cleanup tasks). On the whole, I appear to have been keeping myself busy in a relaxed kind of way, though I haven't yet fallen into any kind of routine. Later, hopefully.

But.

My last few trips down to the house we used to call Rainbow's End (should we call it "Rainbow's Ended" now?) have been increasingly sad and discouraging. We put a lot of ourselves into that house; it was a large part of what we were as a family. Now we're scattered. We'll come back together, mostly, on Whidbey Island in a little over two months; it may very well be wonderful -- I hope it will -- but it won't be the same. I can't keep from thinking of what I might have done differently, over the last few decades(!), that might have made it possible to stay there. Hell, we all made decisions that seemed like the right thing at the time. Can't be fixed.

"I can't fix it!" is probably what I say most often when things are going badly. It always feels like my fault. I don't think I can fix that, either. I should shut up and go for a walk with Colleen.

Notes & links, as usual )

mdlbear: Wild turkey hen close-up (turkey)

So I took the week off from work. I'd originally planned to return from Orycon Sunday afternoon, and go in to work Monday and possibly Wednesday. The best-laid plans... Monday was occupied by the drive back from Portland, Tuesday by medical stuff (including a urology appointment on short notice for Colleen), and Wednesday by waiting for the tech from Acorn to show up and do the proper inspection that the tech who had arrived early on Monday had failed to do. So.

Spent much of the week on personal software projects. Wednesday and Thursday I was mostly hacking in my .emacs file, fixing some long-standing annoyances with html-helper-mode (and incidentally lj-update-mode, which is partially derived from it). Friday and Saturday I worked on the build software for my website Songs pages -- you can see the results (so far -- there's still quite a bit of prettying-up to do) on LookingGlass Folk's Songs. The LgF page was the main motivation -- it's been a broken link on the site for years. The secondary motivation was putting my songbook on GitHub.

In the course of doing this, I finally got around to writing tests for the makefiles -- predictably, they turned up lots of bugs. By no means complete, but I now also have an easily-extensible test framework that I can use for the rest of MakeStuff and my other make-based projects like Honu.

Thursday we had a Thanksgiving dinner that couldn't be beat. Glenn spatchcocked the bird -- this was my introduction to the technique, which lets a 16-pound turkey cook in two hours with a beautifully crisp skin. Recommended. There were just Colleen and I, Glenn and Naomi, and N's kids. The YD had dinner with her boyfriend's family, and Chaos spent the day working on term papers. The tenants ate at C"'s parents'. (I may have to go to subscripts.)

Fair amount of political stuff in the links; not going to re-hash most of it because apparently Post-Trump Stress Disorder is a thing, and I haz it. I can, however, recommend moem's Cybersecurity for the Trumped series, and Tor Browser.

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: (tsunami)

If yesterday is going to be typical of this vacation (I'm taking all of the coming week off), I'm going to need a month or two of work to recover from it. Not fun.

Friday Nova, my main server, developed a corrupted root partition. I've been keeping an eye on that drive for a while, and had a replacement on hand, so I set up a transfer of the home and data partitions and went to bed. So far, so good.

Yesterday was another matter entirely. Installing a new copy of Debian should only have taken an hour or so. Hah! Instead, I was plagued by a long series of problems, which took me pretty much the entire day to finally analyze. These included:

  1. A corrupted download of the Debian installer. It appeared to work ok, but the keys on the right-hand side of the keyboard kept generating the wrong characters! WTF?
  2. Apparently the idiot Intel motherboard I used for my server won't let you change the boot order of your hard disks (despite having a BIOS option that claims to do exactly that), and it considers a USB key to be a hard disk. So if you have a hard drive that doesn't already have a bootable OS on it, it will keep the damned thing from booting.
  3. Snowflake, the box I've been using for a desktop apparently has a similar problem.

I eventually ended up using the only other working spare system, Trantor, to install Ubuntu. I then swapped the disk into the former Snowflake, which is significantly faster and quieter than either Trantor or the Atom board I'd been using for Nova, so that's a win. I also decided, since I now had Ubuntu on Nova, and it was the fastest machine I had, that I would use it as my desktop as well as my fileserver. There are some potential problems with that, but I have to admit that it's convenient.

It will probably take me a while to get everything on (Novo) Nova configured -- I still need to start doing backups, for example, and don't have a web server up yet -- but at least I have DNS and my main file store up and running. But there was a lot of frustration involved.

The frustration made me more susceptible to other sources of stress, so sure enough, that happened too. Kat and Rabbit are in the process of moving out into their own apartment (finally!), so they brought movers in to handle the bed, the futon, and some other large furniture. Which meant taking the seats off the stairlifts.

And, of course, Colleen woke up and walked down the first flight of stairs before calling for help. I hastily put the seat back on the lower lift, and told Colleen (not exactly calmly -- I was pretty stressed at that point) that she should have gone back to the room, sat down, and called for help.

Then the lower lift wouldn't go back up to its charging position. It was already pretty badly damaged from previous moving attempts; it turned out that the limit switch that detects whether the seat is turned properly had finally broken to the point of unusability. Its little cam follower had been crumpled up from previous clumsy seat replacements. There ensued a frantic search for my multimeter (and a hasty battery replacement) so that I could identify the normally-closed contacts on the switch and move the connectors to them.

At that point I went back to my struggles with the computers. Just as I was getting things pretty stable there, Colleen went up to bed. Or tried to: the bottom lift didn't want to go up. Again. More swearing. More switches to reconnect. A quick trip to Google to look up error code E6, which turned out to be the bottom limit switch. Which hadn't given us any trouble up to that point.

... by that time I was a complete wreck. My stress level was not helped by being worried sick -- literally, by that point -- about the fact that the check from my stock sale still hasn't showed up. And berating myself about not being persistent enough to figure out from Morgan Stanley's miserable website how to do a direct transfer.

The one good thing about all this is that I tend to wake up around 4:30 when I'm stressed. When I feel as though I don't have enough time to get everything done, it helps.

It's been a long month. September is fired. Notes & links, as usual )

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

Moderately productive. Two "publishing events".

  1. Sex and the Single Link is up on my "formal" website, Stephen.Savitzky.net. This is, despite the clickbait title, an article about the joy of singly-linked lists.
  2. MakeStuff is up on GitHub. This the first of several projects I intend to put up there; it's the collection of makefiles and scripts that powers all my websites. You can see it in action here.

Apart from that, and a bunch of Quora answers, not a whole lot going on. One my Quora answers led to a good discussion on the comment thread. Fairly prodctive at work, though as usual not quite as much as I wanted to be.

One particularly interesting article for the programmers in the audience, Developer Differences: Makers vs Menders, which seems to describe me fairly well.

Also of note, the first episode of the Lesbian Historic Motif Project Podcast: Ordinary Women by Heather Rose Jones ([livejournal.com profile] hrj on LJ) is up.

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

Fairly productive at work this week, though I lost Friday to an all-day training session. (I made up some of that yesterday in between lab work and my doctor's appointment. Went in early because the appointment wasn't until 1:40, and I wanted to be able to have my coffee before noon.) I appear to be in pretty good health; my blood pressure was 129/75; which is decent.

The training Friday was a workshop on Scrum. Tl;dr: we've been doing it wrong. Which is not unusual. My impression has always been that it works best for things that can be built incrementally -- the idea is to break things down into "features" (corresponding to "user stories") that can be built in one sprint -- typically two weeks -- and end up done, in production, and demonstrated to the customer at the end of that. The theory is that the team gets more and more familiar with their product and their process, so they get better at estimating. And there's an expectation that developers are mostly fungible -- anyone can pick up any of the tasks and finish it in a couple of days. (Specialists like QA, tech writer (we should be so lucky!), and maybe a web developer, don't count.)

So let's look at the project I'm currently on: We have four developers. One is building a new service, one is working on the web front end (and just came on board), and two are working in different, pre-existing services that they've never worked on before. The work being done in the latter case is such that a sizeable number of pieces have to be in place in order for anything to work. Meanwhile, other teams are working on other parts of the same services, with somewhat different requirements. Theoretically, each of the three main developers could work on any of the tasks, but in practice there's a lot of context in each of those sub-projects that it would take a long time for anyone else to ramp up on.

It doesn't help that the manager and web developer are in Vancouver, and that most of the design was done almost a year before the work started, under a different manager, by three developers one of whom got pulled off to work on a totally unrelated project. This leaves only two of us with any real context.

On the other hand, I've been having fun with configuration files and makefiles. The latest hack was adding color-coded labels to the workspaces in my xmonad setup. You say "ws 2 to.do", for example, and you get a color-coded label at the top of the screen in workspace 2. The labels use standard resistor color codes, and include a clock (because the quick thing was to base them on xclock). Here. (Need to get this onto github soon.)

Writing: met my minimum goal of 500 words two days a week, but just barely. Both were in PJ (short for Private Journal), so not on DW or the website where you can see them. Sorry about that.

Notes & links, as usual )
mdlbear: "Sometimes it's better to light a flamethrower than to curse the darkness" - Terry Pratchett (flamethrower)

The only writing I did last week was last Sunday's weekly post. I'll try to do better; hopefully I won't be feeling as harried this week. I did get in some music time -- last Sunday, and yesterday. And some walking with Colleen and Kat, also on Sunday.

Quite a bit of back pain. It's been mostly ok in the morning, but tends to get worse on the way home. Probably something to do with being tired, but also possibly stress. Have I mentioned having trouble identifying my mental state? It's called alexithymia.

The alexithymia also bleeds into problems identifying physical state, because of course they're related. I have trouble distinguishing the physical symptoms of anxiety and hunger, for example. Not to mention distinguishing between wanting food, and needing food. The latter barely registers, and certainly not as hunger, until I suddenly start feeling the symptoms of low blood sugar. Which I have learned to recognize. Or until Colleen notices that I'm starting to snap at people.

Stress is, apparently, another of those states that I don't start noticing until it's been going on too long. And then it bleeds into burnout and depression. (And, no, depression doesn't register as sadness. At all. It's best described as a combination of apathy and despair.) I think I'm noticing a trend here.

I'm getting better at noticing. Look in the notes for an exclamation mark in column 3 -- that means I've actually noticed an emotion while it was happening. They're rare -- the only instance this last week was Sunday.

Speaking of stress, I'm oncall this week. With pages including 6am Tuesday morning -- Prime Day -- and midnight last night. This morning. Whatever. One thing I've noticed is that I don't have enough mental bandwidth. I can't multitask. At all. Period. Things get lost track of.

If a page comes in, I completely lose track of whatever I was doing, including dealing with another page, and it takes me a while to get my context back. Which leads to things like having something like 10 different browser windows open in 8 workspaces, with multiple tabs in each, many of which refer to the same tickets. Because context. And, of course, re-investigating the same thing multiple times because I've forgotten what I was doing an hour ago.

I'm getting a little better at going up to people I don't know and asking for help. But, of course, I'm even worse at remembering names than I am at multitasking, which leads to things like waking the wrong person up at six in the morning. (And forgetting that I had an email in my inbox telling me who the right person would have been. See multitasking.)

(Brief pause -- my desk is being catted on. The absolute best thing I've done for my mental health in years was putting a cardboard box on my desk, attaching it with a couple of screws, and lining it with a towel.)

Back to reaching out and talking to people. I don't think my reluctance to do that has anything to do with what I afraid people will think of me. So, this doesn't seem to have the characteristcs of social anxiety. No, it has more to do with what I think of me, and in particular feeling stupid and at a loss for what to do. Plus total lack of self-confidence, which leads to (or somehow relates to) an unwillingness to "disturb" people.

It's not just at work. Even at home, I take a closed door as a "do not disturb" sign even when I'm pretty certain that the person on the other side (usually N) would be happy to see me. It's hard enough when I know they're expecting me, though I'm getting a little better about that.

In a slightly different direction, some links from [personal profile] ysabetwordsmith about emotional self-care (see Monday, below) proved unexpectedly triggery and anxiety-provoking. So we're talking low self-esteem here, maybe. (Maybe?! Let's get real here.)

It's been a long month this week.

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

You may want to start with Part 1

 

Xmonad is a tiling window manager. That means that, with very few exceptions, it lays out all of the windows in your workspace so that they completely fill the screen. You can have multiple layouts, and flip between them with a single keystroke. You can bring a workspace (there are 9 by default, but you can add more) to your screen with a single keystroke, or send a window to a workspace.

And the whole thing is configured using a text file that is actually a program, written in the functional language Haskell. I'll get to that later.

One of my main gripes about Gnome, etc., and one of the things I miss the most about CTWM, is that when you first start a program its window shows up at some random location on the screen, with whatever size the program thinks is appropriate. If you don't like those choices you have to move and resize the window yourself, and then do it all over the next time you log in. (There are some exceptions -- many newer programs remember where you put them last, and older programs, from the CTWM era, can be given a starting geometry.)

Xmonad's layouts are all deterministic, which is to say, predictable. When you start a program, you know exactly where it's going to be on the screen. When you change the layout, you know where everything is going to go. If you want to move a window into the main position (most layouts have one; e.g. the left-hand column) it's (as usual) just one keystroke to put it there.

But the best thing, and the reason I switched to xmonad in the first place, is the way it treats multiple monitors: it simply assigns one workspace to each monitor.

Undock your laptop, and its screen stays exactly the same. The workspaces that were shown on the other screens simply go back into hiding with all the others, and are still only a keystroke away. When you have multiple screens, you can move a window to another screen, or bring a workspace to a screen, or warp the pointer to another screen, all with single keystrokes.

When you go to a conference room and plug in a projector, a workspace immediately shows up there and its layout automatically adjusts to the projector's resolution and aspect ratio. When you get a new computer -- all the developers at work got new laptops just a month or two ago -- just copy your configuration files to it and everything will be exactly the same as it was on the old one. (Sometime later I'll write about my portable configuration, which makes it possible for me to set up my entire working environment in mere minutes.)

 

So let's go a little deeper into those magic keystrokes. First of all, you have to know that all of the commands (you can't really call them shortcuts) include a key that xmonad calls "Mod" (short for "modifier", of course). Mod is initially defined as Alt, but the first thing any Emacs user is going to do is redefine it as something else, usually the "logo" key. (That's the one on the left between Ctrl and Alt that usually has a Windows logo on it. If your keyboard has replaceable keys you may be able to get a penguin for it.) On old laptops that don't have a logo key I use Ctrl-Alt, but that's a matter of taste.

You also probably want to know that Mod-? gets you a list of all the commands. And that there's a fantastic collection of tutorials, documentation, and sample configuration files at xmonad.org.

When xmonad starts up, you see a totally empty, black screen. Most people, myself included, add a status/navigation bar at the top, but you don't have to. I'll get to that later. You can start a program by typing Mod-P, or open a terminal window with Mod-Shift-Enter. You will immediately notice that the first window you open fills the screen. If you open another, xmonad will tile the screen with them, showing them side by side.

If you start a third program, it will get added to the right-hand column. You can probably see where this is going. When you move the mouse pointer into a window, it gets a thin red border to show you that it has "focus".

If you decide that you started things in the wrong order, move the pointer into the window you want to put in the left-hand column (the "master" column) and hit Mod-Enter. You close a window you're done with using Mod-Shift-C.

Here's where it gets interesting: Mod-Space will switch you to a new layout, with the master column turning into a master row, and all the other windows across the bottom. Hit Mod-Space again, and the currently-focused window goes full-screen. (I reconfigure my full-screen layout to put a row of tabs across the top. Wondering how to see the hidden windows? Mod-Tab moves focus to the next window in the stack. It also works in other layouts, so you don't need the mouse to move focus around. If you spend most of your time in a terminal and an editor like vim or emacs, you can throw your mouse away and still be productive. Mod-Shift-Tab moves focus to the previous window.

Mod-2 puts you into a second workspace. There are nine of them. (I add two more -- 0 and -.) If you want to move a window, say from workspace 2 to workspace 1, use Mod-Shift-1. That's kind of a recurring theme in xmonad -- Mod-something does one thing, and Mod-Shift-something does something related.

You can see that in action if you add an(other) monitor. Now, workspace 1 is in the left-hand screen, and 2 is in the right-hand screen. Think of the two of them as West and East.

Now, Mod-w will move the focus (and the mouse pointer) into the West screen, and Mod-e will move the focus into the East screen. Mod-1 through Mod-9 will bring that workspace into whatever screen has the focus. If the other workspace was already visible, they trade places. (Some people don't like that, so you can change it so that it just moves focus into the other screen if you select a workspace that's already visible.)

Add a third screen to the right of East, and call it Right. Now, Mod-r and Mod-Shift-R do exactly what you would expect. (There are no bindings for T, so I suppose that if you have space for a fourth screen you could use it for that.)

There are more key bindings, to move focus (Mod-j and Mod-k focus the next and previous window, respectively; shifted, they swap the focused window with the next or previous window), to shrink and enlarge the master area (Mod-h and Mod-l respectively), or increase or decrease the number of windows in the master area (Mod-Comma and Mod-Period respectively).

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

As I mentioned about a week ago, I've been trying to write more. And since my current obsession is a program called xmonad, well, ...

This is incomplete: it's about the first day's worth (I've been trying to write about 500 words per day). Comments and suggestions are, of course, welcome.

 

My new 27" monitors arrived at work; I took advantage of the change to rearrange my work space. Before, it was the set-up I've had for most of the last three years -- monitor in front on a stand, second monitor on the right, and my laptop on the left. The new laptop, however, has a decent keyboard (with trackpoint and three buttons), and the monitors between them occupy about 2/3 of the desk.

The new arrangement has the laptop dock under the "middle" monitor; the laptop, being a business-class Dell, has both a pointing stick and a middle "mouse" button. The laptop's keyboard is decent enough that it can replace the thinkpad keyboard I've been using for the last couple of years -- it's a high-end Dell, and has both a pointing stick and a middle button. (The middle button has part of the Unix desktop environment since the mid 1980s; it means "paste", and I use it all the time.) The monitors are about 50% bigger, pixel-wise, than the laptop, and are arranged "traditionally" with the laptop on the left.

You can probably see the problem with this arrangement. The total workspace is about 7000 pixels wide, and it's not even arranged in a straight line -- to get from the laptop to the "middle" monitor you have to move the cursor to the right, but the natural direction would be straight up. What's more, when you undock the laptop the whole thing collapses down to a "mere" 1920x1080. It's no wonder that most of the programmers in my team have opted for a single 30" monitor, and keep their laptop (almost invariably a mac) closed while they're using it.

Fortunately, I anticipated this problem months ago, and started using a window manager called xmonad.

 

One of the things I love most about Linux is the fact that the program that manages the layout of the screen and the behavior and appearance of the windows on it is not part of the operating system. It's a separate program, sensibly called a "window manager", and it runs in user space as a perfectly ordinary application that just happens to have a couple of extra hooks into X, which is the (also ordinary) program that actually controls the display, the keyboard, and the mouse.

Being an ordinary program -- and not even a terribly complicated one -- anybody can write one, and many people have. For a long time I was using one called TWM (Tabbed Window Manager, but the T originally stood for Tom's). Later I started using CTWM (Claude's Tabbed Window Manager), because it introduced the then unfamiliar notion of multiple workspaces. (Before CTWM, these could only be found in an experimental system at Xerox where they were called "rooms". Apple introduced them decades later, as part of MacOS X.)

You've probably heard of Gnome, KDE, and Ubuntu's horrible Unity desktop environments. Down at the bottom, they're just window managers plus a couple of utilities for doing things like putting up the familiar bar (Gnome calls it a "panel") full of menus, launcher buttons, clocks and other widgets. You can, in fact, run gnome-panel under any window manager, and I did for a while. They also include a "session manager", which handles things like starting the panel and making sure that applications get notified when you log out, so that they can save their state and exit cleanly. I've been using Gnome for years, and loved it for its configurability.

But Gnome's configurability comes with a cost -- every time you move to a new computer, you have to spend an hour clicking around in control panels and property windows to get everything set up the way you like it. And every time there's a major upgrade, something is a little different. It's a cost I no longer have to pay.


Part 2

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

Hmm. Interesting week. Mostly in the Chinese sense.

My boss seems to be somewhat more confident in my abilities than I am. It is not clear that this is entirely a good thing, especially if it tempts me to become complacent. But, yeah. Low self-esteem. I haz it.

I think I've managed to spend a few minutes noodling on the guitar every day this week. Mostly minor and suspended chords, but still. Music. It does tend to confirm that my mood is mostly minor and suspended.

My home hacking continues to be centered around xnomad. I've pretty much abandoned gnome at this point. Xmonad is blazingly fast, lightweight, works beautifully with a varying number of monitors, and seems to help me concentrate on the task at hand.

I've also upgraded a couple of netbooks to Ubuntu 16.04; not entirely successfully, but the one with hardware problems is the smaller of the of the Dell minis. The keyboard was crap when I started, and has not been helped by the fact that the hard drive is underneath it. Swapped the 16G SSD for a 100G hard drive pulled out of something a long time ago. That, and getting through a couple of boxes of shredding, has at least given me some sense of accomplishment.

The most "interesting" day was Friday, though, when I got home and it finally occurred to me to research burnout. Um... yeah. Nearly a perfect match for the problems I've been having at work over the last year, not to mention the depression, dysthymia, occasional sleep problems, and the fact that I lost ten pounds over the course of a month or so last year. (Not that I'm going to complain about that! But...)

Anyway.

I actually teared up reading, in Ten Questions for Meaningful Career Development, "2. Am I willing to believe that my efforts matter, at least to me?"

I think what I need to do, over the next year or so, is semi-retire. I can't afford to fully retire, and probably wouldn't want to for years. But something less stressful, maybe part time, ... yeah. The hard part will be finding it. There aren't really a whole lot of low-stress jobs for an ageing computer curmudgeon. If you spot one, let me know.

Notes & links, as usual )
mdlbear: Welcome to Rainbow's End (sign) (rainbows-end)

The big news for this week is RainbowCon 1, this coming weekend. But other than that...

Colleen lost her uncle in a car crash. So not exactly a good week. Busy and somewhat rough week at work. Lots of tidying, moving of boxes, and so on. So my back hurt most evenings. Naproxen is my friend.

Finished my taxes, sort of at the last minute. Owed about the same as last year, which was a pleasant surprise, considering that before I started Sunday it was showing about twice that. I could have handled it, but glad I didn't have to.

N and G moved down to their new suite in the basement. It'll be gorgeous when they get moved in. I helped with putting up shelves, but the last two I put up weren't level. Grump.

... and when I couldn't give Naomi a coherently practical reason why I was prioritizing clearing a way to the garage, she said, "Oh. It's an emotional need then. Go ahead." Oh. Yeah; I guess I have emotions these days. And other people can still notice me having them when I can't. Which uttterly fails to surprise me.

Can't think of anything else worthy of mention.

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

So.... not too bad of a week. Busy, which is good. I gave a presentation at work on Friday; it appears to have come across well despite not being nearly as smooth -- or as well-prepared -- as I would have liked. There is, of course, a strong connection between those two: I did most of the work Sunday and Monday. Still, ...

I spent most of my spare time configuring xmonad and studying Haskell. Haskell is a pure functional programming language, with a somewhat peculiar syntax. Xmonad is a lightweight tiling window manager, written in Haskell. I love it! Its use of screen space is extremely efficient, and you pretty much don't have to worry about how windows are arranged because it's automatic. (You get your choice from a wide range of possible arrangements. Configurable as heck.)

When I had to go back to gnome (while I was trying to figure out how to get a network manager applet) I found myself trying to tile windows with the mouse. Ugh. Now that it's in pretty good shape I'm going to put it on my work laptop. It's glorious on a laptop.

The latest Ubuntu upgrade seems to have done slightly weird things to html-helper-mode. At this point I'm inclined to go with the flow and stop trying to use hanging indent for paragraph tags. Not as pretty, but it actually works ok in HTML5, which gets back to human read/writeability from the strictness of XHTML.

Chaos and Rabbit are moving in. Hopefully by mid-day today. Notes & links, as usual )

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

I seem to have mostly switched to xmonad as my window manager. This is a Good Thing -- I seem to be better able to concentrate with a less-cluttered screen. (On the other hand, I'm less productive while I'm still hacking on the configuration. That may be less of a good thing. There are, unfortunately, still a few things that don't work well in it.

Meanwhile, despite being fairly productive at work, I have gotten behind on a couple of longer-term things -- namely taxes, and a presentation that I'm supposed to be giving next Friday. (It's more fun to read Learn You a Haskell for Great Good!.)

It was quite warm several days this week. That is not expected to last, but it does indicate that Spring may be on its way. Not to be confused with the Spring Framework. Which I am not happy with.

I am also starting to do yard work again, after neglecting it for almost all of last year. (Partly because depression; not clear on the rest.)

Sigh. Too many things have fallen by the wayside. I, perhaps, am one of them.

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

The week's notable events were Mother's Day (including an expedition to the Burke Museum with the Younger Daughter), and Rika's house concert on Thursday. The latter was very thinly attended, but we had fun anyway. We have seating for 25-30 people. I found a couple of folding camp chairs on sale at Walgreen's for $10; used one last night for a couple of songs.

I turned up several long-missing items in the course of re-arranging furniture and looking for other missing items (which of course were nowhere to be found -- there may be a conservation law in effect here). Emmy put the Great Room into concert configuration and back; she's kind of unobtrusively amazing.

In the software area, I now have a workable 2-monitor configuration using x2x(1) between nova (the "server", running Debian Jessie) and trantor (the "desktop", running Ubuntu Trusty Taur). It's a very usable setup, if slightly odd-looking.

I'm back with my own group at work, though still working on some of the stuff I've been on loan to. I'm not really happy there, but it's a job.

ETA: and I somehow managed to post this a day early. :P

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

On the health front, I may finally be learning to relax the muscles in my lower back that make it hurt when I walk. Maybe. It also seems to have a lot to do with how heavy my shoulder bag is, so that's going to be an ongoing problem. A backpack would be better, except that it's hard to get off when I take a seat in the bus, and unlike a shoulder bag I can't swing it around when I want to get at something like my wallet.

I've finally started doing some serious system administration/scripting work to get my website working directories the rest of the way under git control. That's done -- I can now say "make deploy" in a web directory and have it committed, pushed to the remote repo, and pulled into the website with no further attention.

In the process, I had to write a script for converting a directory from CVS to git. There are a couple of challenges in that process because the old CVS repositories were in pretty bad shape, with stuff not having been checked in consistently. Not like a well-maintained software project, in other words. Bad bear. No cookie. My websites don't use cookies anyway.

The associated asset archive is going to be harder, because some directories have large media files in them. Like, um... the audio. The goal is to eliminate the use of rsync snapshots for backups (for reasons I will probably go into in more detail in a later post).

Detail in the notes, as usual.

raw notes, with links )
mdlbear: "Sometimes it's better to light a flamethrower than to curse the darkness" - Terry Pratchett (flamethrower)

Advisory 01/2014: Drupal - pre Auth SQL Injection Vulnerability

A "highly critical public service announcement" from Drupal [LWN.net] "Automated attacks began compromising Drupal 7 websites that were not patched or updated to Drupal 7.32 within hours of the announcement of SA-CORE-2014-005 - Drupal core - SQL injection. You should proceed under the assumption that every Drupal 7 website was compromised unless updated or patched before Oct 15th, 11pm UTC, that is 7 hours after the announcement."

Impressive. I think this is an appropriate place to quote one of my father's aphorisms: "A locked car with an open window is NOT a locked car."

If PHP is your open window, you may as well leave the keys on the dashboard where they're easy to see.

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

I spent a lot of time yesterday (and today) ripping CDs so that they can be packed. The ones that aren't in FreeDB, and a few of the ones that, for some reason, my Linux box refuses to read, got sent over to the Mac mini; it worked on a lot of them. I'll have to write a script to translate the filenames to match the conventions I'm using on Linux, but that's easy.

We had an electrician come in to look at our fan/lights -- the fans work fine, but the lights don't. Turns out it's not the remote controls, it's the stupid ballasts. I looked at one -- the insulation on the wiring harness is brittle. Should be easy to replace, in that case.

A little random hacking in the makefile templates, prompted by the fact that the Makefiles in theStarport.org are hopelessly out of date.

Some good links in the notes, several of them music-related.

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

A very productive couple of days at work; I hit my (largely symbolic) code freeze deadline yesterday evening at 5pm, in spite of having spent far too much time in meetings. There's another, very hard, very real handover deadline coming up on Monday -- I'll be spending the rest of the week documenting and testing.

I walked a little yesterday, and a full three miles on Monday. I was actually present in the moment for much of Monday's walk, and noticed that it felt better than when I spend the time worrying or beating myself up over things I should have done years ago. Not that there isn't plenty of time for that.

I also finished the data-entry for taxes, ran my summary program (which sorts the expenses into categories that are easy for me to put into the forms), and imported last year's data into The Program Formerly Known As TaxCut (henceforth probably TPFKATC).

One of the most annoying things about modern GUI software is that it has no notion of "current directory" even if you start it from a command line in the damned directory; it thinks that you want to put everything in "Documents" or some-such, and often won't even do you the courtesy of exporting into the same directory you saved the document into. Sometimes that's useful, e.g. if you're working on only one project at a time and all your exported .wav files (to give a current example) go into the same directory. If you jump around between projects it's annoying as heck.

I've been reading How To Be Happy, available for free on 17000 Days. There's a section on optimism, which had a different definition from the one I'm used to; you'll also find it in this post. I've always said that I'm a pessimist because I like pleasant surprises. But I've never much liked surprises of any kind, and I'm obviously not expecting any pleasant ones. The definition in the book is:

The biggest difference between optimists and pessimists is that optimists assume good things are permanent and pervade every area of their lives, but assume bad things are temporary and isolated to their limited context.

Pessimists, obviously, assume the opposite. So I'm a pessimist because I expect anything pleasant to be a surprise -- unplanned, unlikely, and temporary. It makes a difference.

As for links, there were several good ones, mostly about computer security. State of Texas exposes data on 3.5 million people is one -- the money quote is:

Often when I am talking with people at shows and seminars I ask them if they have an encryption program in place. Nearly always the answer is "Of course! We have deployed encryption to over 80% of our laptops already."

I then ask about the servers, databases and other critical storage locations of sensitive data and I see a scary look in their eyes... They usually respond with "Oh, that's OK, that information is all inside of our firewall."

Yeah, right.

The other one, Security researcher warns over Dropbox authentication security flaw, is kind of obvious. I mean, if you set up automatic syncing with someplace on the net, it's obvious that your credentials are going to be stored on your local machine, and can be exposed if your account is compromised. Duh.

Beware!!

2009-02-09 11:13 am
mdlbear: (sureal time)
Beware: UNIX Time to Read 1234567890 On Friday the 13th
perl -e 'print scalar localtime(1234567890),"\n";'
Fri Feb 13 15:31:30 2009
mdlbear: (hacker glider)

So yesterday evening, rather than do anything actually useful like my sales taxes, I sat down and finished transpose.pl, which automagically transposes lead sheets with chords enclosed inline in [square brackets]. Based on the file extension it either uses "#" and "b", or "\sharp" and "\flat".

Of course, the sales taxes really have to get done this morning, along with paying any bills due at the end of the month (when I'll be out of town). And two phone calls, which still scare the hell out of me, to AT&T about my cell phone service and fiber. The cell phone call should have been made a month ago, and is probably too late now to help with my previous astronomical bill. Maybe even with the current one. My finances suck, and I suck at handling them.

(09:54) Sales taxes done.

mdlbear: (hacker glider)

Adeona: A Free, Open Source System for Helping Track and Recover Lost and Stolen Laptops

Adeona is the first Open Source system for tracking the location of your lost or stolen laptop that does not rely on a proprietary, central service. This means that you can install Adeona on your laptop and go theres no need to rely on a single third party. Whats more, Adeona addresses a critical privacy goal different from existing commercial offerings. It is privacy-preserving. This means that no one besides the owner or an agent of the owners choosing can use Adeona to track a laptop. Unlike other systems, users of Adeona can rest assured that no one can abuse the system in order to track where they use their laptop.

Adeona is designed to use the Open Source OpenDHT distributed storage service to store location updates sent by a small software client installed on an owners laptop. The client continually monitors the current location of the laptop, gathering information such as IP addresses and local network topology that can be used to identify its current location. The client then uses strong cryptographic mechanisms to not only encrypt the location data, but also ensure that the ciphertexts stored within OpenDHT are anonymous and unlinkable. At the same time, it is easy for an owner to retrieve location information.

[...]

Adeona is named after the Roman goddess of safe returns.

(from InfoWorld)

OpenDHT looks very interesting in its own right.

mdlbear: (hacker glider)

One of Colleen's little pleasures in life is Nethack. She never bothered to learn the cursor-movement keys, though, which are based on vi. She's always used the arrows. They work on the PC version, and they've always worked for her on the Linux version, too. So it was a little surprising that they didn't work on her EeePC.

Odd that there didn't seem to be a config-file option to enable them.

I finally looked at the example config file for nethack-x11. All the way through it. And found a familiar-looking key-translation table. Oh.

As it turns out, I had encountered this problem a dozen years ago, and fixed it by putting exactly that four-line key-translation table into the household's shared Xdefaults file. And forgotten that I'd done it.

Dumb bear. Was a smart bear, once upon the time.

mdlbear: (hacker glider)

Yes, I definitely seem to have fallen into a modern-day version of The Programmer and the Elves...

...still a lowly programmer -- and is now stuck for the foreseeable future maintaining this horrid crock of a Fortran program, written by elves! After all, nobody else can understand how it works. It has variables named Shamrock and Rainbow and Misty_Morning_Dew, and some of the most ferocious assembly language subroutines to be found outside the jungles of Borneo.

And the moral of the story is: Never do the impossible. People will expect you to do it forever after.

Well, maybe not quite that bad. But it's a horrid crock of a form and workflow system built on top of a beta version of Java that are both 10 years out of date... Somebody upgraded Java, and it broke.

So I commented out the one place where it was using the old, incompatible KeyStore class, and it's back to crashing a lot instead of every damned time. That's an improvement. Of course, now it's only pretending to create and verify DSA signatures. But since you can't fill in a form without logging in to the server with your Unix password, there was never any real reason for the digital signatures in the first place.

This still leaves the uncomfortable question of why a horrid crock of a research experiment written by two people a full decade ago is still better for our lab's workflow than anything we've been able to turn up in the open source world. Suggestions?

Or is there still some research left in that topic? Hmm.

mdlbear: (ubuntu-hello-cthulhu)
Open Source Java Technology Debuts In GNU/Linux Distributions
Latest Releases of Fedora and Ubuntu Feature OpenJDK-based Implementations

SANTA CLARA, CA April 30, 2008 Sun Microsystems, Inc. (NASDAQ: JAVA), Canonical Ltd. and Red Hat, Inc. (NYSE: RHT), today announced the inclusion of OpenJDK-based (http://openjdk.java.net) implementations in Fedora 9 and Ubuntu 8.04 Long Term Support (LTS) Server and Desktop editions, furthering the promise of Sun's open source Java technology initiative.

In addition, the NetBeans 6.0 Integrated Development Environment (IDE) (http://www.netbeans.org) is being delivered as part of the Ubuntu 8.04 LTS release and Canonical has certified Ubuntu 8.04 LTS Server Edition on several Sun x86 systems.
(From Groklaw's news picks.

Hacks

2007-07-16 11:39 pm
mdlbear: (hacker glider)

Added short-form track credits to some of the various listing formats. In general, this replaces timings (which mostly aren't all that useful except on places like the tray card) with the name of the songwriter, or lyricist/composer if they're different. You can see the results here, for example.

mdlbear: portrait of me holding a guitar, by Kelly Freas (freas)

It crossed my mind at the last Très Gique gig at Westercon that my usual sound check song, "Jabberwocky" as a talking blues, is totally lame. A proper sound check song should be a throwaway, sure, but it also has to be something that everybody in the group can sing on, with verses we can trade off singing, geeky, totally silly, and loud.

"Old Time Computing" came to mind. Then I came up with:

When your drummer plays a doumbek
You had better run a sound check
Or you'll end up sounding like heck
And your audience will flee...

... Possibly with a chorus about a real-time musician, after which things could easily degenerate into verses about emacs/vi, unix/vms, and other software religion. But I'm not going to go there right now.

mdlbear: (hacker glider)

So now that I have this nifty ogg player, the obvious thing to do is to put the oggs for my album on it so I can listen to them. There are a couple of subtleties to this, since all the soundfiles have uninformative short names that don't sort in proper track order.

The solution was to add a new format to my TrackInfo program that makes symlinks (in a subdirectory) that have proper long names starting with a two-digit track number. Then it's a simple matter of invoking it from the Makefile, and rsync'ing the music player from the subdirectory.

Q.E.F.

BTW, it sounds really good. Clean. Claves don't work in "Daddy's World", though. Sound out of place.

mdlbear: "Sometimes it's better to light a flamethrower than to curse the darkness" - Terry Pratchett (flamethrower)

Word Processors: Stupid and Inefficient, a 1999 essay by Allin Cottrell. Still, sadly, as true as it was then.

(From Don Marti.)

Currently I do almost all my writing in HTML using a plain text editor, GNU Emacs. My filksongs are still all in LaTeX with a couple of custom macros for typesetting chords and passing metadata to my various scripts, and to-do lists and random notes are in plain text. I hardly ever have to think about how a document is going to look when it's printed, beyond tweaking with a song's layout parameters so that it fits on a single page. About the only thing I have in a word processor at the moment are business cards.

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

OK, I'm an idiot. But at least I managed to avoid a major embarassment when I decided not to start burning disks last night -- a wise decision, given that it was nearly midnight and I'd already printed a batch of 10 jewelcase inserts upside-down -- and give the CD-ROM part a once-over in the morning. Damned good thing.

In addition to leaving out the copyright license notices on the index page, I had succeeded in leaving out the .ogg and .mp3 files that were the main reason for having the disk in the first place! It took me about three hours to clean up the mess. It's presently held together with spit and baling wire, but somebody reading the CD-ROM in a web browser will at least have valid local links to visit if they start at the top, and somebody browsing the files directly will find the audio in places that at least make sense.

Also discovered that my nice new Plextor drive doesn't seem to want to write any faster than 8x, though it could conceivably have been the media that I did the initial test burns on, or something else I was doing on the machine at the time (since it worked fine at full speed a couple of days ago). OK, I now have two side-by-side boxen in the office, Harmony and Trantor, and they both work.

mdlbear: (audacity)

Added reverb to the vocals on "Someplace in the Net" (which improved it considerably); last night I also did some mixing on "Programmer's Alphabet" and "Paper Pings". Ran into some mysterious bugs in Audacity last night working on "Net", so I pulled down the latest updates from the CVS tree and rebuilt it. Several stupid mistakes (you really do need cvs update -d if you want to get all the new subdirectories) and a number of apt-get's to fetch missing libraries later, I had a shiny new Audacity 1.3.3 -- the bugs appear to be gone, and there are some welcome improvements in the UI.

In other news, my left leg isn't hurting, and the infected big toe on my right foot seems to be improving. These are both Good Things.

Happy Bear.

(9:15 reverb on "Paper Pings". 9:35 reverb on "Programmer's Alphabet".)

mdlbear: (abt)

... but it looks as though I'll be starting one anyway. this post by [livejournal.com profile] catsittingstill got me thinking about tweaking my CD and website build tools (edit to fix broken URL -- how did it end up being "starpnetort.com"?) to make them more generally useful. Right now they're specific to me, my website layout, and the idiosyncratic file format I use for lyrics. But it wouldn't be hard to generalize them, and I think a lot of people, especially in the filk community, would have a use for what amounts to a singer-songwriter's web toolkit.

I'm not going to do more than think about it between now and whenever my CD is finished -- hopefully Baycon.

mdlbear: (ccs)

Got the Makefiles back into fully-useable shape after the transition to 32-bit floating point .wav files. My assorted disk-burning programs won't burn them directly, so they have to be converted to 16-bit first. This gives me a chance to pull them all together and normalize them to the same average level, which is also a good thing.

Burned a test disk which I will listen to in the car tomorrow.

mdlbear: (ccs)

Despite having other things to do, I managed to get "World Inside the Crystal" into pretty decent shape -- the main thing it needed was bass cut on the guitar track to tame the boominess that resulted from having the mic slightly above the strings when I recorded it. I think I can take care of "Silk and Steel" this evening as well. (9:58 ...except that "Silk and Steel" needs to have its guitar part redone -- too much bleedthrough on the vocals otherwise.)

This markes something of a milestone: 9 tracks out of 18 are basically done, and only two need me to do any actual recording at this point.

My conversation with Jeff Rogers yesterday at the party, plus some of the other feedback I've gotten, has left me feeling pretty good about putting the live version of "High Barratry" on the CD. I pushed the .wav file up on the web so he could work on it. Jeff, like me, is in favor of a clean acoustic sound with the lyrics clear and understandable.

Almost finished with the switchover from 16-bit wav files to 32-bit. If I export the final mix in floating point it means I can normalize the tracks without losing any bits, so I'll have more headroom for mixing. I believe most mastering software takes floating point as well. Only thing left is actually building the disk TOC, but I don't need that immediately. Maybe not at all, if I let the duplicator put the disk together from uploaded track files.

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

Joyce had to reschedule our practice session, so I've been catching up on a few other things, like making sure that all my lyrics pages link to the corresponding PDF, OGG, and MP3 files (if they exist, of course). (Making sure they get rebuilt when new oggs or mp3s get added is left as an exercise for another day.) I do have a tentative setlist, though.

Next thing I'm planning to do this evening is upgrade my main internal fileserver (nova) from Debian Sarge (the current stable release) to Etch (testing, and soon to be stable). I've done this on several systems by now and so far it's gone pretty smoothly. Email might get disrupted for a while, but hopefully not too long. (update about an hour and a half for the upgrade, as it turns out.)

The major accomplishment at work was getting the touchscreen on my old Linux tablet PC working in Etch. We have two of them -- they were originally made by Element Computing (now defunct) and shipped with a hacked-up Xandros installed. The software was distinctly flaky, and I was never able to find a version of Linux that worked well until a couple of weeks ago. I finally figured out the proper incantation for the touchscreen, which turns out to use the "fpit" (Fujitsu) driver. It was called something different in XFree86.

Tomorrow's task will be making the touchscreen continue to work when it's rotated into portrait position, set up an auto-login for the account we're running the demos in, and then duplicate the whole thing on the other machine. And then try to get the built-in wireless card working. Should be... um... interesting. Yeah, that's the word.

mdlbear: (abt)

Spent most of the day trying to figure out why I couldn't burn a working second session (with a CDROM image) onto the bonus disk, making a CD-Extra. A little before dinner I found that it worked on my fileserver, which is running Debian Sarge rather than the newer Etch. Whether the problem is in the software or the drive, and which piece of software it might be in, remains to be seen. But now that I know it works, I can deal with other things.

Well, the [livejournal.com profile] flower_cat has gone to bed -- not feeling well at all -- so I think my best course is to do some more debugging, work on the booklet text for CC&S, and start on the set list for my concert at Consonance. Recording will wait until tomorrow afternoon.

Update: oddly, it seems to be working now. It does seem to require writing the whole disk in track-at-once mode using wodim.

mdlbear: (kill bill)

In the course of putting together the graphics for my upcoming CD, I've discovered that essentially the only way to exchange files with both my artist collaborators and my duplicator is to use Adobe Photoshop and Illustrator. I've even gone so far as to contemplate getting a Mac mini to run them on -- it would be a useful addition to the local computer collection in any case, and runs Ubuntu just fine.

Imagine my disgust, then, on discovering that Adobe doesn't support the Intel Macs yet. This means that there is no Mac that I can go out and buy that will run their stupid software. And neither of my Windows boxes will support their software, either -- not enough RAM, and wimpy CPUs.

At one point,years ago, Adobe ported all their software to Linux and made it available for beta testing, and all of it ran on Solaris as well. Then they stopped. They're nearly as evil and disgusting a monopoly as Microsoft, and if I could avoid both of their product lines and stick to my OS of choice I'd be a happy hacker indeed.

update It seems that the hang-up is caused by yet another piece of proprietary software: all of Adobe's products were developed on MetroWorks' C++ compiler, which doesn't support the Intel macs either. Apple switched over to GCC, which apparently cuts some corners that Adobe was counting on. It's still disgusting -- it doesn't matter which proprietary software you're relying on, you're still going to get screwed. All I can say to the poor drudges putting in their overtime at Adobe is: you should have known this was coming.

mdlbear: (copyleft)

This is big, folks! You can read about it here or here or by following links from this story on Groklaw, which points to Sun's press release. Check out the banner picture.

I don't think I'm exagerating when I say that this is going to have as big an influence on the software scene as Netscape's open-source release of Mozilla, and probably a lot faster.

mdlbear: (hacker glider)
Remember my earlier post about open formats, and how Mark Pilgrim switched to Linux after 22 years on Apple hardware? Well, here's his Essential Software List -- it's an update of this list from 2004. I see we're both members of the Church of Emacs
mdlbear: (hacker glider)

I've been happily playing with Boodler, a program that generates "soundscapes" -- continuous, varying streams of sound. My favorite so far is "pwrain.Rainforest" -- "rain in the rainforest". It's all programmed in Python, so it's infinitely tweakable.

Most Popular Tags

Syndicate

RSS Atom

Style Credit

Page generated 2019-02-20 03:37 am
Powered by Dreamwidth Studios