Squid's Scribblings

Is this thing still on?

2025-01-30T00:00:00+00:00

So I may have slightly stopped updating this blog for over a decade. Ah well, it happens.

I don’t know if I’ll be posting to it any time soon, outside of this update, but on the off chance someone is still subscribed to the Atom feed despite it disappearing for years and years, hello again!

This is also the first time the Jekyll version of this blog has been hosted on my own server, since tying it into my NixOS server config gives me a nice easy way to have it track updates to the repo.

See you all around, possibly sooner than another decade from now!

Twas the night before the night before Christmas

2013-12-23T00:00:00+00:00

And all through the house, not a creature was stirring - except for me, generating my new GPG public key, with finding a use for it being an informal resolution for the future (not really a New Year’s resolution, since I’d prefer to start before then if I find something).

Feel free to add it to your keyrings, or whatever your PGP client happens to use, and I will guarantee that if I am using GPG at all, then that’s the keypair I’ll be using, so in the unlikely event that someone tries to impersonate me for whatever reason, they wouldn’t have that key, and you’d know something was up.

PSquid/Bit (depending on how you know me best :P) out!

Informal Analysis of an Unknown Algorithm

2013-06-19T00:00:00+00:00

So, as of earlier today I’ve been working through the Algorithms course on Udacity, and I wanted to work through the lesson 1 naive algorithm analysis example in writing, so I could get a good grasp on the actual process of analyzing it. Then I figured I might as well write it up a little neater so I could actually publish it somewhere for posterity, and this blog post happened.

I’d also like to preface this by saying yes, I’m aware people could potentially (though I don’t think I get enough linking for it to be likely) use my analysis and conclusion to “cheat” at the problem. And all I’ll say to that is… if you’re just looking for the answer to the question, rather than trying to work it out, you’re probably not going to get much out of the course.

So, without further ado, let’s get stuck in.

The code given for the algorithm itself is fairly simple:

def naive(a, b):
    x = a
    y = b
    z = 0
    while x > 0:
        z = z + y
        x = x - 1
    return z

So… what does it do?

Well, first I’ll start by breaking it down into two chunks - initialization, and then the main loop.

The initialization is simply setting x and y as variables initially duplicating the values of a and b (and is pretty much useless in real terms, since Python passes ints by value, but that’s irrelevant to the analysis), and adds a new variable z, which starts out as 0.

The loop is the real meat of the algorithm, and it does two things:

It increments z by the value of y.
It decrements x by 1.

It also runs only while x is greater than 0 - combining this with decrementing x by 1, and nothing else changing x, this means we know the loop body will run x times.

Since x is never used to directly modify z, we can now ignore it beyond remembering that it’s the number of iterations of the loop. That means that in practical terms, the loop’s only effect is to increment z by y each time it runs.

Since y never changes, this means x times, we increment z by y. Or, in other words, it is (x * y) more than when we started.

Finally, since z starts as 0, its final value is 0 + (x * y), where x is the original x, or to simplify, z = x * y. Since the original x and y were equal to a and b, the algorithm’s purpose is to multiply a by b.

(Thanks for reading, if you got this far without boredom. I’d be interested to hear if anyone found this post interesting, and especially if anyone would like to see me step through similar processes when I run into them.)

The Curse of Microblogging?

2012-02-28T00:00:00+00:00

This is something more of a ramble than a clearly-directioned post. As such, you may wish to skip over this one, as it’s likely to end up somewhat less useful to others. I’m writing it mostly to get it out of my mind.

Lately, I’ve been wondering just why it is that I don’t often post to my blog (recent times have been something of an exception). It seems to me there are two possible explanations.

The first is that I’m simply not doing that much of interest. This would be a sorry state of affairs indeed, and one that I make efforts to avoid; there seems little point to a life spent on the mundane alone.

The second possibility is that I simply don’t have much more to say than I’ve already offloaded via microblogging; in my case, that would be on status.net. This one seems, on examination, to be the more probable cause, especially given how frequently I post (it varies a little, but it’s reliably more often than once an hour when averaged over an entire day; allowing for sleep, it would be more frequent).

So, armed with that knowledge, I’m now wondering what the best approach is:

I could abandon my blog, but as my more recent posts have shown, there are still subjects I want to get across that can’t adequately be tackled in ~140 characters. Also, I have something of a sentimental attachment to the domain name, and I have no real use for it as a generic landing page.
I could abandon microblogging. This is essentially a non-starter, however, as there are plenty of people I converse with on status.net that simply aren’t anywhere else I go.
The nuanced approach: continuing to microblog, but also posting summaries (of sorts) of larger subjects here. This does entail some duplication of effort, but I feel the more long-lasting nature of a blog post would be a boon for many things that otherwise just cascade off into the past if limited to a microblog timeline. The act of writing some things again may also give me a change to reevaluate details of them, I suspect.

While I’m unsure whether any of this has any strong grounding in fact, I think the third approach is a good direction to strive for in future, so I’ll be making efforts to adopt it as a habit. Wish me luck. :)

OpenID and Status.net

2012-02-21T00:00:00+00:00

EDIT: This post is still marginally relevant to OpenID in general, but the status.net instance in question is defunct.

Today I discovered something cool about status.net, that I hadn’t known before. Namely, that you can delegate your OpenID to it. I already had an OpenID identity referenced in my site, but it delegated to Google, which had two problems:

It wasn’t linked to any one account, so services I logged into would tend get confused if I was logged into a different Google account.
It would often forget I was logged in, even if other Google services stayed logged in just fine.

Luckily, it turns out that not only can a status.net profile (such as mine) be used as the OpenID endpoint I delegate to, but the markup necessary is already present in the profile source itself, so you don’t even have to remember the little details of the syntax.

The markup you’re looking for are the two <link>s with "openid.*" rel fields (there are also some openid2 fields in there, but those are largely irrelevant for the purposes of this post), so in my case that would be these two lines:

 <link rel="openid.server" href="http://micro.fragdev.com/main/openidserver" />
 <link rel="openid.delegate" href="http://micro.fragdev.com/psquid" />

You can, of course, also just modify those directly to match your instance URL and username, if you don’t even want to open up your profile’s source.

With those replicated in the <head> section of this site’s pages, I simply provide “psquid.net” as my OpenID when a site asks for it, confirm the login with Fragdev if I’ve never used that site before, and then all is good. No random profiles, no unexplained logouts. It just works exactly how it should.

The Joys of Jekyll

2012-02-14T00:00:00+00:00

Time to dust off the old blog-o-phone again, I think.

A little while ago, I moved my blog to a blogging engine of my own design and creation. And all was well and good. But after a while, I started to find little things I didn’t like in my original solution, and gradually the entire codebase devolved into a functioning, but crufty, relic. And I spent far more time working on the engine than actually writing any posts, which is toxic for a blog, especially since 90% of code changes won’t result in any obvious visual changes.

So I started looking around for a solution that didn’t need me to maintain the engine itself, but still had the features I wanted - namely:

Markdown (or Textile in a pinch, though I still prefer Markdown)
Complete control over page layout.
Version controllable
Ability to serve it from my own server a plus, but not a requirement

After a little searching, and based tangentially off moggers87’s recommendation of the very similar hyde, I settled on Jekyll. It satisfies the first two requirements easily, and the third and fourth were satisfied together by my decision to use Github Pages to host it (another nice result of that is that you can see the source of any post exactly as I wrote it). Since the output is just HTML and CSS, I could also have hosted it on my server, but I was going to use git to track it anyway, so choosing Pages killed two birds with one stone.

The much more relaxed visual style was born out of my growing distaste for the old yellow/black colour-scheme, and my desire to keep the style as simple as possible this time round.

To sum things up: just from having imported my old posts (mostly copy-and-paste, since they were already in Markdown on my old engine), and now from having written this post, I can safely say that (as the title may well have already told you), Jekyll is an absolute joy to use. If you haven’t tried it, I really can’t recommend enough that you go and do so right away!

PSquid out.

Watching the Tumblrweed roll by

2011-08-17T00:00:00+00:00

Just a short blog post this time. My tumblr is being repurposed as purely a reblog account for reblogging tumblr posts that I feel are worth it. It will not have any new actual posts, as those will all be over here.

Putting a dent in blogging

2011-06-28T00:00:00+00:00

EDIT: Since this version of the post is on a github-hosted site, there are no comments, so the post below is factually incorrect (for this version, anyway).

What really makes a blog (besides the posts, obviously) is probably the comments.

The trouble is, if you have to sign up for a blog to comment, that immediately lowers the chance that you’ll actually do so. But go too far the other way, and you open yourself up to waves of spam from opportunistic spam bots.

Luckily, there’s a third way; require an account, but not one that is unique to a single blog. Several of the big blogging engines do it, with ways of having a global account that works for all blogs using that engine. Then there’s generic authentication providers, OpenID et al, which can be used in a similar way.

And then, there’s what I’ve now done with this blog: status.net comments. Since I intend to broadcast “new blog post” messages on identi.ca anyway, it’s not too difficult to harvest replies to that dent, and present them as comments, just the same as the built-in comments. Maybe I’m not the first to do it, but I’m proud of my solution, especially since its reuse of my existing statusnet module allows it to be used with just about any status.net instance.

Anyway, it’s switched on as of this post, so barring any catastrophic failures I couldn’t get to occur in testing, it should now be live. Enjoy!

Ink 'n' Mustard

2011-06-22T00:00:00+00:00

Sounds delicious!

But in all seriousness, hello, and welcome to my new blog!

It’s back on my server, instead of tumblr, and this time, it’s completely coded by me, from the engine (SquidInk) all the way up to the theme (the titular “Ink ‘n’ Mustard”). Which means that I get any and every feature I could possibly want, because all I have to do is write it (scratching one’s own itches is so very satisfying).

I’m also using this move back to spur me into getting some more posting done, so keep your eyes peeled for more soon.

(OLD) Starting afresh.

2011-02-19T00:00:00+00:00

NOTE: This post was originally posted on my tumblr blog. It has been imported here for posterity’s sake, in case tumblr ever deletes my account for inactivity/ceases to exist/is taken over by trained apes.

Unfortunately, in the process of migrating from an old VPS to a shiny new one, my Wordpress posts were not, as I had originally thought, backed up. Now, I intended to move to tumblr anyway, but it would’ve been nice to bring my posts with me.

Still, there was nothing I couldn’t do without, and hopefully the fact that tumblr is not hosted on my server (it would fall over a lot more often if it was) will help avert such missteps in future.

And, honestly? It feels rather nice to start 2011’s blogging with a clean slate. Obviously, this blog is not yet fully set up, but that should happen over the next few days or so.

PSquid out.