Year: 2015

I’ve been seeing a lot of people complaining about the nuclear deal. There seems to be an especially vocal group who feel that we should be investing in renewables rather than nuclear. Some of these people hold up Fukushima as a warning about how bad things can go with nuclear power. There’s a lot to say about this topic, and I’m not going to take the time to write a book about it, just drop some links and facts for the interested reader.

It’s interesting how your tools affect your choices and how you can end up in a place which works for your current needs but doesn’t make the next step you’re trying to get to easy.

To understand my current situation regarding managing my files, it’s probably best to go into a little bit of history.

Early computer use: no syncing

I enrolled as an undergraduate in 1997. When I arrived on campus I was given my very first e-mail address and I remember spending huge amounts of time in the computer labs writing to all of my friends (using a program called Pine, which looked like this):

Pine screenshot

Files were small and you carried them around with you on things that we called stiffies. The Americans called them 3½-inch floppy disks. The capacity of a stiffy was 1.44 MB. This was enough for most of your work in a semester. Stiffies were notoriously unreliable, so you never really worked on the disk only, because for all you knew, they could die tomorrow. Stiffies were for moving files from one computer to another, not for long-term storage. Some people had CD writers, but campus computers didn’t.

I didn’t have a computer in my res room until my second year, and when I did it wasn’t connected to any kind of network until third year. I could only check my mail and do IRC on campus computers.

Once I got a computer in my room, an issue emerged: sometimes I would start working on something in my room and I would need to continue working on it on campus. So I would copy it to a stiffy and ride my bike to campus, where I would copy it over and keep working. This process led to copies of the files on both machines with no clear way to keep track of which one I had worked on last. So if I forgot my disk on my desk and worked on the campus copy instead of the version I had in my room, things would break. Luckily files were small at first, but technology rapidly improved and by final year (2000) we had CD writers. At this point, we had Internet connections, but they were so slow that it was much faster to burn a CD and bike to campus than to send the data over the Internet. The fastest dial-up modem speed was 56 kbps, which would require more than a day to transfer the 700 MB that fits on a CD.

For my entire undergraduate career, therefore, I could never sync my account on campus with my computer at res or the one at home. I just had some random files in various places which I had to transfer piecewise.

Postgraduate: two computers, external HDD

Two desktops, laptop, local network

A change: cheap Internet

A remaining issue: campus proxy/firewall

Side-effects

Why change what works?

A student was having difficulty using a class I had created to represent transfer function objects. I discovered that they were actually placing these objects in a numpy.matrix and trying to multiply things by one another. To my surprise, this actually worked! I had to investigate. The code here is all in Python.

I created a quick tracing object which just kind of logs the operations that are done on it as an expression:

class operation:
    def __init__(self, name):
        self.string = name
    def __repr__(self):
        return self.string
    def __str__(self):
        return self.string
    def __add__(self, other):
        return operation("({} + {})".format(str(self), str(other)))
    def __mul__(self, other):
        return operation("{}*{}".format(str(self), str(other)))
    def __radd__(self, other):
        return operation("({} + {})".format(str(other), str(self)))
    def __rmul__(self, other):
        return operation("{}*{}".format(str(other), str(self)))
       

    In []: a*b
    Out[]: a*b
    In []: a + b
    Out[]: (a + b)

import numpy as np
In []: tracer = np.matrix([[a, b, c],
[d, e, f],
[g, h, i]])

In []: tracer*tracer
Out[]:
matrix([[((a*a + b*d) + c*g), ((a*b + b*e) + c*h), ((a*c + b*f) + c*i)],
        [((d*a + e*d) + f*g), ((d*b + e*e) + f*h), ((d*c + e*f) + f*i)],
        [((g*a + h*d) + i*g), ((g*b + h*e) + i*h), ((g*c + h*f) + i*i)]], dtype=object)

    In []: np.exp(a)
---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)
 in ()
----> 1 np.exp(a)
AttributeError: exp

    def exp(self):
        return operation("e^({})".format(self))

In []: np.exp(a)
Out[]: e^(a)