• A const reference.  I don’t want to copy it, but I promise not to modify it, either.
• A reference.  I might modify it.
• A copy.  I might modify my local copy, but not the original.  I’m getting a copy, after all.

Easy peasy in C++.  In Java?  Uh, I pass all objects by reference. The interface says nothing about modification.  Pass me a Map and maybe I’ll modify it, maybe not.  You don’t know, and you can’t enforce it.  Unless you pass me a Collections.unmodifiableMap().  Then my code might break!  There might be some odd little case left over where I do modify it, in spite of documentation comments to the contrary.  C++?  I declare it to be a const reference, and now the compiler will prevent me from modifying it.  I like that quite a bit.

I also like const methods, and you really can’t have const without const methods.  The Java way it to throw exceptions.  I’d rather have the compiler tell me something at compile-time than have the runtime system fail at runtime.  But I’m weird, I suppose.

Programming

I spend my time (recently) writing a mishmash of Python, C++, and Java. It’s interesting to switch back and forth.

What’s a good idea and what’s a bad (or dangerous) idea in computer language design? We’ve got a lot of candidates, and a lot of opinions.

I’ll list a few here, along with a few places where they show up. I’m not saying C macros are the same as, or even similar to, Lisp macros. Just trying to clarify the spectrum.

I’ve heard someone, at some point, say each one of the items below is a good idea / bad idea. Dangerous in the hands of a novice? Yes, but then so is any computer with a network connection.

• Preprocessors (C, C++)
• Macros (C, Lisp)
• Multiple Inheritance (C++, Smalltalk)
• Operator Overloading (C++, Python)
• Closures (Lisp, Haskell)
• Generics (Java, Ada)
• Template Metaprogramming (C++)
• Casts (C, C++)
• Strong or Weak Typing (Scala, Lisp, Python, ML)
• Fixed-Point Math (C# and COBOL)
• Fixed Integer Types vs. “Numbers” (C, Lisp, Python)
• Garbage Collection (Java, Lisp, ML)
• Manual Allocation / Deallocation (C, C++)
• Everything is an Object / Some Things are Primitives (Smalltalk, Java)
• Auto-(Un)Boxing (Java, C#)
• Indentation is Significant (Python)
• First-Order Functions (ML, Lisp)
• Lambdas (ML, Lisp, Python)
• Type Erasure (Java)

Did I leave out your favorite / most reviled language feature? Complain below. I included type erasure at the end of the list. Does anyone think this was a good idea for Java???

Apple

The hard drive in my Mac has failed.  Again.  For those of you keeping track, this is the third time.

It’s a hassle, but it is usually okay, since:

• TimeMachine is always there, making backups and keeping them up to date.
• Apple support is wonderful.  We can’t send back the hard drive, but they let me open the case and remove the drive without voiding the warranty.

Sadly it is also a pain because:

• The MacBook Pro is some of the most poorly designed hardware I have ever encountered for maintenance.

It’s not just that it is a laptop.  Disassemble a MacBook Pro and then disassemble a ThinkPad and tell me what you think.  There is a clear difference.  I won’t speculate as to why things are the way they are… but they are that way.

Apple listened, and has made it much easier to replace the hard drive in the new MacBook Pro.  They’ve also made it much harder to replace the battery.  I understand somewhat the reasons for the latter… but still.

The Process

Here’s how you replace the drive in the MacBook Pro model I own.

1. Four tiny screws on each side of the case. Phillips.
2. Two tiny screws in back. Phillips.
3. Four long screws on the bottom. Phillips.
4. Three tiny screws under the battery holding the memory cover. Phillips.
5. Two tiny screws in the battery compartment securing the front. Phillips.
6. Remove the memory.
7. Two tiny screws in the memory compartment. Torx.
8. Remove the back, then front of the keyboard panel. Remove the connector.
9. Two tiny screws holding a metal shim on one side of the hard drive. Phillips.
10. Remove the tape and adhesive-backed connectors from the back of the hard drive.
11. Carefully remove the hard drive and the metal shim.
12. Four “bumpers” attached to the hard drive with tiny screws. Torx.
13. Congratulations! Now I have removed the drive. Out with the old, in with the new.
14. Now reverse the process to re-assemble the MacBook Pro.

It’s just that easy.

Reliability?

I have a ThinkPad X40.  It always works.  It has never failed, and it’s pretty old for a laptop (2005).  I have a T60p, and it Just Works.  I’m running Ubuntu on it these days, since it boots in under a minute.  The Mac?  Well… it has a new drive in it now.  I’m pretty sure it’s a lemon.

But I get to use Leopard.  I really, really like the OS.  If I could run Leopard on a ThinkPad… (yes, I know, you can).

• Reified generics or
• Closures

In the interim, I offer the following Java code to the world.  Does it help?  Use at your own risk.

This is a class that wraps the collections interface to provide for recovery of the type parameter.  To use it, make a new instance and pass the class object for the parameter to the constructor, along with the original collection.

package gypsum.util;
 
import java.util.Collection;
import java.util.Iterator;
 
/**
 * This class packages some implementation of {@link Collection} along with
 * the class object for the type parameter of the collection.  This allows
 * getting the type of objects in the collection using the {@link #getType()}
 * method, and then using the resulting class to perform casts.  This basically
 * creates a "reified" generic collection (of sorts).
 *
 * @param    Class of data held in this collection.
 * @author sprowell
 * @version $Revision$ $Date$
 */
public class TypedCollection implements Collection {
 
    private Class type;
    private Collection implementation;
 
    /**
     * Make a new instance.
     * @param type              The class object for the type of elements.
     * @param implementation    The implementation.
     */
    public TypedCollection(Class type, Collection implementation) {
        if (type == null) {
            throw new NullPointerException("The type is null.");
        }
        if (implementation == null) {
            throw new NullPointerException("The implementation is null.");
        }
        this.type = type;
        this.implementation = implementation;
    }
 
    /**
     * Get the type held in this collection.
     * @return  The type held in this collection.
     */
    public Class getType() {
        return type;
    }
 
    /**
     * Recover the original typed collection.  In order for this to work,
     * the correct class must be supplied; otherwise you will get a
     * {@link ClassCastException}.  Use this as follows.
     *
<pre>     * TypedCollection&lt;Foo&gt; coll = oldcoll.recover(oldcoll.getType());
     *
     *
 
     * This converts from {@code TypedCollection&lt;?&gt;} to
     * {@code TypedCollection&amp;ltT&gt;}, so you recover the generic type
     * parameter.
     *
 
     * This may seem backward, or even a little contrived.  Blame it on
     * the Java generics system.  The reason you must pass the class
     * object <em>in</em>, even though it is maintained here, is that
     * the compiler must know the type of the object <em>at the point
     * you use this method</em>.  Thus you can do the following.
     *
<pre>     * public void print(TypedCollection&lt;?&gt; coll) {
     *   if (coll.getType() == String.class) {
     *     TypedCollection&lt;String&gt; coll = coll.recover(String.class);
     *     for (String str : coll) {
     *       System.out.println(str);
     *     }
     *   }
     * }
     * &lt;/pre&gt;
     *
     * @param    The type of the desired collection.
     * @param kind  The class object for type T.
     * @return  The correctly cast generic collection.
     * @throws  ClassCastException
     *          This instance is <em>not</em> the type desired.
     */
    @SuppressWarnings("unchecked")
    public  TypedCollection recover(Class kind) {
        if (kind == type) {
            return (TypedCollection) this;
        }
        throw new ClassCastException("Incorrect cast.");
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#add(java.lang.Object)
     */
    @Override
    public boolean add(E arg) {
        return implementation.add(arg);
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#addAll(java.util.Collection)
     */
    @Override
    public boolean addAll(Collection arg) {
        return implementation.addAll(arg);
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#clear()
     */
    @Override
    public void clear() {
        implementation.clear();
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#contains(java.lang.Object)
     */
    @Override
    public boolean contains(Object arg) {
        return implementation.contains(arg);
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#containsAll(java.util.Collection)
     */
    @Override
    public boolean containsAll(Collection c) {
        return implementation.containsAll(c);
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#isEmpty()
     */
    @Override
    public boolean isEmpty() {
        return implementation.isEmpty();
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#iterator()
     */
    @Override
    public Iterator iterator() {
        return implementation.iterator();
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#remove(java.lang.Object)
     */
    @Override
    public boolean remove(Object o) {
        return implementation.remove(o);
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#removeAll(java.util.Collection)
     */
    @Override
    public boolean removeAll(Collection c) {
        return implementation.removeAll(c);
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#retainAll(java.util.Collection)
     */
    @Override
    public boolean retainAll(Collection c) {
        return implementation.retainAll(c);
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#size()
     */
    @Override
    public int size() {
        return implementation.size();
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#toArray()
     */
    @Override
    public Object[] toArray() {
        return implementation.toArray();
    }
 
    /**
     * {@inheritDoc}
     * @see java.util.Collection#toArray(T[])
     */
    @Override
    public  T[] toArray(T[] a) {
        return implementation.toArray(a);
    }
}

computer science: n. a study akin to numerology and astrology, but lacking the precision of the former and the success of the latter.

– Stan Kelly-Bootle, The Devil’s DP Dictionary

I’d say the above is no longer true: computer science is successful.  But it really isn’t very precise.

The field of computer science is probably the area of knowledge that is closest to pure gibberish. On my shelf are books with the titles Python in a Nutshell, Enterprise Java Beans, and MySQL & mSQL.  A random passage reads:

In this example, gmpy manages to compensate for the float’s “representation error” and emit the exact fraction that you presumably meant rather than the mathematically exact one, which tends to be less useful.

– Python in a Nutshell, p. 374

You get the point.

This is because where other fields invent new names for new concepts, computer science tends to borrow old names for new concepts. Thus “bean” and “object” take on new meanings. Even mathematics tends to coin terms carefully, and use names for specific concepts, such as “Jacobi identity.”  You won’t confuse that with a desert topping, and other mathematicians will typically know what you mean.

Sometimes things get really confusing as perfectly good words get used up.  Like the word word, which means 16 bits (bits?) on most computers.  Wouldn’t want to confuse that with a dword, or double word.  You get the confusion of the specific versus the general, when words like object, entity, and attribute get used up.  Then you get text like the following (I plead the Fifth on where this originates):

If the entity is a class object then the collection of known object classes is updated with the provided class object.  Otherwise the object’s class is declared to the container manager prior to being serialized.

Fred Brooks pointed out that most fields study what’s out there; natural phenomena, if you will. Computer science studies its own invented concepts, and they could have been implemented in different ways and often are; there are many competing ways of doing things.

All this is relatively important. Computer scientists, programmers, and others who work in the field develop an affinity for this sort of silliness and help perpetuate it, often just for fun.  Need a name for your just-in-time compiler?  How about ElectricalFire?  (Apparently the other name proposed was, famously, “sexual chocolate.”)

The goal isn’t to be perspicuous (or I wouldn’t have used that word, after all), but to have fun.  And in the end, isn’t that what computer science really should be all about?

If you have additional advice, let me know and I’ll add it to this post.  I’ve tried to keep it simple and make it a summary; I don’t explicitly tell you the steps to do any of this stuff since you’ve all got access to Google.  Still, if you want more information on any of this, let me know.

My Network

First, a word about my home network.  We have several machines on the network, including laptops, desktops, palmtops, and “boxes” like TiVO’s and printers.  These machines run Windows XP, Apple OS X, and Linux.  It’s a fairly diverse network and requires some effort to keep things working, at least the way I want them working.  Some items I can configure to make them secure, some I really can’t (like the TiVO’s).

I’m currently using cable broadband, and it is sufficient for my needs.  I have my home network set up to allow me to access it remotely and (relatively) securely, so I have to think about security more than you might have to.

Are these steps overkill?  Maybe.  But people have had their network connections used to download and upload Bad Stuff such as child pornography, and people have been prosecuted and sent to prison for the contents of their computer hard drives.  Ultimately you are responsible for what’s on your computers.  I consider most of what is listed here “reasonable maintenance.”  But I’m a computer security professional, so I’m biased.

Windows XP

You are probably running some version of Windows.  Here are some things you should do.

1. Turn on the firewall.  If you have a third-party firewall, you can use that.  If not, make sure the Windows firewall is on.  If you have an up-to-date installation of Windows, you should be fine.  For the record, I use the Windows firewall that is part of XP.
2. Install all patches for Windows.  This means running the Windows Update utility.  Even if you have your machine set to automatically get updates, you should still do this manually, at least once per week.  Do not trust the automatic update!  There are lots of reasons why it might not work.
3. Install anti-virus software.  I won’t make any recommendations here, but I will tell you I use Symantec (or Norton), because it is provided by my employer.  Your employer or ISP may provide you with free antivirus.  You should check.
4. Keep your anti-virus software up to date.  Even if you have it set to automatically update itself you should occasionally explicitly update it.  Don’t trust automatic updates!
5. Install spyware protection.  I recommend (and use) Spybot Search & Destroy. You can get it from here.  You can set it to update itself automatically and to run automatically, but even if you do, you should still update it and run it yourself about once a week.
6. Stop using Internet Explorer.  Go and download Firefox and use it.  I won’t go into all the reasons for this.
7. Make sure you have passwords set.  Set a password for every Windows user, and disable the guest user and remote administration.

Now there are a lot of other little things you can do.  For instance, you can install safety plugins for Firefox to block scripts.  The above are what I regard as the bare minimum.

There are lots of other guides available online.  Look here for a guide with nice screenshots.

Finally, if you are running Windows XP Home, consider upgrading to Windows XP Professional, or some flavor of Vista.  Actually, at this point, you might want to skip Vista and wait for Windows 7.

Wireless Networking

I run a wireless network at home.  Do not be confused; wireless networks are not secure.  You are broadcasting your network packets to anyone and everyone.  If you are pathological about security, don’t use wireless.  The U.S. government’s Federal Desktop Core Configuration (FDCC) explicitly forbids wireless, and the reasons are good.  Don’t believe me?  Run out and buy a copy of Wi-Foo.

Okay, so you are going to run a wireless network anyway.  Fine.  Do the following.

1. Set your SSID.  More wireless routers come with the site ID set to something like “linksys.”  Change this.
2. Enable encryption and do not use WEP.  Turn on encryption on your router, and pick a good passphrase.  My passphrase is over 20 characters in length.  WEP is trivial to crack, and some computers actually come with software pre-installed that will crack it.  Don’t use it.  If your wireless router doesn’t support anything other than WEP, get a new one.  They’re fairly cheap.
3. Disable broadcasting your SSID.  You know your SSID.  There is no reason to broadcast it.  This means you have to manually add your network on your Windows machines, but that’s okay.  It also means your neighbor doesn’t immediately see that you have a wireless network.
4. Turn on your MAC filter.  Every network card has an associated identity called it’s MAC address.  Your router should allow you to set it so that only specific MAC addresses can connect.  You have to manually add every computer that will connect wirelessly, but it really isn’t that hard.
5. Disable remote administration.  Many wireless routers feature remote administration, meaning you can configure the router from outside the network.  You don’t need that, and you don’t want it.  If it is on, turn if off.  If you have a machine plugged directly into your router (not connecting by wireless), consider disabling configuration over wireless, as well.  You can only configure it from a physically plugged-in machine.

Now your wireless network is more secure.  But intruders can still detect your signal, sniff packets, inject packets, capture these packets with software like Kismet, “spoof” your MAC addresses, and compromise your network.  The point is that this takes some sophistication; your neighbor probably can’t do this, and thus can’t use your network connection to download porn.  There are plenty of unsecured networks; intruders will go somewhere else.

Routers

If you have a wireless router, you have a router, and can probably ignore this section.  If, on the other hand, you have the wire that comes in from the wall connected directly to your computer, perhaps by a cable or DSL modem, consider getting a cheap router and installing it between the modem and your computer.  Then configure it.  Often the default configuration of a router allows anyone to modify the settings.  You don’t want that.  Set a password on your router.

Why?  Routers provide a level of protection between you and the Internet.  Even if ports are open on your machine and it is vulnerable, a router can stop traffic that would otherwise get to your machine.  In fact, most routers are configured to do this by default; you have to explicitly open ports to enable P2P applications, for instance.

Vulnerability Scanners

Get and run a vulnerability scanner.  If you are running Windows you should download and run Microsoft’s free Microsoft Baseline Security Analyzer.  Do it now.  I’ll wait.

I routinely run a tool called Nessus.  This is a fairly sophisticated network vulnerability scanner, and it can produce some unexpected and occasionally frightening results.  It scans your network for open ports and reports on vulnerabilities it finds.  Sadly the free version is now limited to the “home” feed, but you should still consider using it.  Do not run this on a corporate network! Running this kind of tool is something the network admins probably do, but is likely grounds for revoking your network access.  Just run it on your personal, home network.  Nessus runs on Windows, Linux, and OS X, but you only need it installed on one machine since it scans the entire network.

Run the vulnerability scanner periodically.  The list of known vulnerabilities changes, and updates to your operating systems (and family members) can open new vulnerabilities.

P2P Software

Using LimeWire?  FrostWire?  Vuze?  Miro?  Transmission?  Or any of the other P2P clients?

Explicitly configure P2P applications.  These applications can transmit your data over the network (that’s what they’re for) and can download information to your computer (that’s also what they are for).  Make sure you know precisely what files on your computer, if any, are available for download externally.  Also, keep in mind that running these clients advertises your computer on the network.  Make sure the computer you use is reasonably secure by following the advice above.  Oh, and keep P2P programs up to date.  Vulnerabilities occur in these programs and new versions are released.  Check them and always use the latest version.

There have been some stories recently about people’s tax returns and other private data being easily available on the Internet, despite this problem being known for years.  This is the result of not configuring P2P software on machines, so that all files are shared by default.

Encryption

Encryption is now easy and simple.  Really.  You can use whole-disk encryption from Windows, and you can encrypt folders on OS X.  This is built into both operating systems.

TrueCrypt is a nice, free, on-the-fly encryption system for keeping your private data private.  It’s easy to install, runs on most platforms, and let’s you create and use multiple volumes.  You can get as crazy about security as you want.

The point of this is that information like your tax return, Quicken account, etc., can be stored in an encrypted folder, and transparently decrypted only when being used.  Then if files are stolen off your machine… they are encrypted.

Intrusion Detection

Okay, if you are really getting pathological about security, consider installing and running an intrusion detection system (IDS).  I do this.  These are programs that observe your network traffic and look for “suspicious” activity.  I run Snort.  This is not for the faint hearted.  Still, if you store company information on your home machines, you might be attacked for that data.  Really.  I’m not kidding.

Backup

Backup your machine.  If you have a Mac, just get an external hard disk and turn on Time Machine.  If you have Windows, you need to do more.  From My Computer you can right-click a drive, open Properties, and select Tools.  You should see backup options there.  You want an external hard disk and periodic backups.

Good security consists of several items:

• Detect intrusion attempts.
• Resist intrusion attempts.
• When intrusion is successful, repair the damage.  This is where backups come in.

You don’t want to have to throw away all your data if your computer is compromised.  Plus, and I guarantee this, your hard drive will eventually fail.

Remote Access

I can access my home network remotely.  If you don’t need to, I suggest you don’t.  If you do, here are some things you can do.  I assume a modest level of sophistication here.

1. Use a Linux or FreeBSD box.  Forward the ports you want on your router to a machine running Linux or FreeBSD, and not some other OS.
2. Change the port for SSH, VNC, etc.  Use some port other than 22 for SSH.  For VNC, don’t use display zero or one.
3. Set strong passwords, and consider disabling passwords for SSH.  My SSH server only allows connections authenticated by certificate.
4. Use port knocking.  Install knock and knockd, and use them to connect.  Port knocking is a wonderful solution to keeping ports closed, unless you explicitly want to use them.  I use one-time knocks that open a port just long enough to connect.

One other final, perhaps funny, item.  My home system sends me text messages for certain events.  I used to do this using my wireless provider’s web interface and curl, but now I can just send email, thanks to my crackberry.  It’s nice to know what’s going on.

Summary

Security requires routine maintenance.  Run all updates and scans manually about once a week or so.  Why?  To make sure everything is working and to say conscious of any problems.

Owning a computer is really like owning a car.  Both require care and periodic maintenance.  You should get familiar with how things work on the computer.  You don’t have to be a network professional, just get familiar with the software that’s available to help you.  In fact, based on some of the folks I’ve known with degrees in networking, being a “network professional” might not help, and might even hurt.

Hope this helps!

(I know there is ML support for Eclipse, but it’s nowhere near Java support.)

All that said, I complain about Java a lot.  Almost as much as I misuse italics.  Anyway, here is my list of peeves in the current Java, in no particular order.

• Lack of reified generics.

I’ve written my fair share of C++.  I’m used to the idea that when you instantiate a template you get a class.  That’s not how Java works.  The whole type erasure idea makes me crazy almost every day.  I’d be okay if the type information was available at runtime, but of course it isn’t.  I’m not the only one bothered by this.

• Lack of closures.

Did I mention that I like ML?  Haskell?  Lisp?  I understand closures, and I want to use them.  I don’t want a watered down version like with generics.  I want real closures.  Everyone doesn’t have to use them; they aren’t an idiom for idiots.  I can make do without them, but why should I have to?

• Lack of macros.

It’s not politic to miss #define, but I do.  There are lots of places where I would just love to use a compile-time macro.  Recently we had a problem on a project of lots of strings getting created because of debugging statements (log4j) that were not enabled.  Doesn’t matter; the string gets created.  The compiler can’t optimize it out, since debugging can be enabled at runtime, and I get that.  But do I really need that most of the time?

Also, I use certain design patterns that cry out for a macro.  Want a factory?  Most of it is boilerplate.  Could I do this with the new annotation system?  Probably, but… you can’t replace a class with an apt-generated class; you can only generate new classes.

• Lack of delegates.

This would probably not be an issue if we had closures.  However delegates are easily understood, and very useful.

Okay, that’s my Java rant for today.  Back to writing Java…

There’s an excellent program called mimeTeX that renders math without a TeX installation. I used it with Drupal and DruTeX. Now I’m not using Drupal… so I need to find another way to display math.  Oh, mimeTeX still works, but you have to explicitly encode the link.  I’m way too lazy to do that.

Update: I’ve been experimenting with using [ tex ]…[ /tex ] from the mimeTex plugin to WordPress. It’s working now, but I needed to do two things to make it work.

• Create a cache folder under my wp-content folder.
• Modify the plugin to point to my local installation of mimetex.cgi.

I also had to go into the cache folder and delete all the files that were created during the process, so I could see the effect of the changes. But now it works!

Here’s an example of an equation array. Note that you need to use & to insert the required ampersand delimiters.

[ tex ]\begin{eqnarray}
 \overset{*}{\triangleright}\!(uvx) & = & \triangleright\!(\overset{*}{\triangleright}\!(uv)x) \\
 & = & \triangleright\!(\overset{*}{\triangleright}\!(\overset{*}{\triangleright}\!(u)v)x) \\
 & = & \overset{*}{\triangleright}\!(\overset{*}{\triangleright}\!(u)vx)
 \end{eqnarray}[ /tex ]

So… shouldn’t everyone just install LaTeX by default? Shouldn’t all CMS ship with some math solution? Of course!

Over the past month my hard disk failed in my MacBook Pro (again), my wife’s MacBook, and our old Dell laptop.  The Macs are both still on warranty, but the Dell’s not.  Odd, you know?  Anyway, this shows the general usefulness of two things: external hard disks and Apple’s Time Machine software.  I’m currently running my Mac off of an external hard disk until I can get it back to Apple.  Fun!