That is perfectly fine. I’m not here to be a politically correct person. This is my space on the Internet—and I’ll say what I like here. You know how I believe in freedom and its natural limitations? No? Well, I’ll say this until the day that I die: one person’s freedom ends where another person’s freedom begins. I’m free to say what I like, and you’re free to read it in any way you like or even not at all. Now, I won’t talk about other people by name on my blog unless I have permission to do so—especially if I’ve nothing positive to say, so don’t say that I’m not being at least a bit nice to you—but if I write a post here and it’s about you and you know that from nothing other than reading that post, maybe that is saying something more than what I have said here. If that has ever been the case in the past, or if it ever becomes the case in the future, then know this: it’s better you read what I have to say about you here, than wish that I were willing to spew my unfettered anger in your direction in person. And shoot, if you’re doing things that are illegal (such as running unlicensed proprietary software) and I haven’t turned your ass into law enforcement, you should be thanking whatever deity you believe in. Honestly.

Anyone who knows me—even if they do not know me well—knows that there is absolutely nothing that will make me angry like willful ignorance.  “Ignorance is bliss,” as the saying goes, but ignorance when combined with the lack of desire to fix it in what you claim to be a domain of specialized knowledge which you possess is just plain inexcusable. If you manage a network, you should know the basics of how it all works. There are people that I know that manage Windows networks and know nothing—not even the high level overview—of how Windows networking actually works beyond the painted pixels on the screen. Guess what? That means that you really do not know what you’re doing.

And lest anyone get offended or butt-hurt over being called ignorant, don’t. Let’s remember what ignorance actually means, and remember that it’s not an insult or a sleight against anyone—everyone is ignorant about many things, even in their own fields of work and expertise. However, willful ignorance in one’s own field—that is, ignorance that you’re not willing to fix all on your own like a big boy or girl—is absolutely something that you should be offended at! It is simply not possible for a single human being to know everything, even in his or her own specialty.  We have reference works, documentation, and vast seas of information in every field that I can think of, more than can fit in a human brain. But what matters is that you know what you know, and know what you don’t, and know how to find it out quickly and efficiently. And that means having a sort of self-initiative. And for that matter, I’ll even point people in the right direction, if they’re willing to do the legwork themselves to decipher the information once I’ve pointed them at it. I certainly don’t spoon-feed though, and if you expect that (in your own field, no less!) then I will stand by my assertion that you should not work in that field at all. And I will stand by that assertion whole-heartedly, no matter how much that gives a person pain.

If you’re ignorant about something that you never do nor have a desire to do—say, you’re an auto mechanic and you don’t care to know how to sew or crochet—then that’s fine; that’s your choice! But if you work in a field, and you learn that there is something that you don’t know, then learn it. Or at least learn where you can learn it when you need to, and get a friggin’ overview in your head. Read any single RFC and you’ll realize that there is no way that any of us can memory every single detail of every single specification for every single type of system that we manage. It’s just not possible without spending so much time studying that as to make it impossible to get anything useful actually accomplished. But if you manage a mail server and you don’t know the first thing about SMTP or POP3 or IMAP or whatever-else protocols your mail clients and servers are using, yes, that’s a problem. You certainly do not need to be able to have a conversation with your SMTP server, but you should know how to look up just how to do to that should you ever have to do any really low-level troubleshooting or log capturing. You shouldn’t need to know how to speak any application layer network protocol directly for that matter (though a lot of the text based ones are simple enough that you can learn them as needed over time). But you absolutely should know how to find the information that tells you how to speak those protocols if ever you have a need. And you should know enough to be able to make intelligent decisions on things like physical network infrastructure, management of your client and server operating systems, and so forth.

As an example: I am nowhere close to an expert on Windows—and I know this. (I will say that I know an awful lot about the way Windows bootstraps itself, as I have had to fix systems with multiple infections by hand because there were no automatic tools available to fix the system… but that does not make me an expert on the whole system, and probably not even the bootstrapping process of the system.) But I will research any issues that I encounter while supporting Windows users and find out—empirically, if I must—how to fix the problem. It’s what I do. And there are many, many places where I can find that sort of information, including booting up a copy of Windows itself and trying to figure it out that way. It does probably take me a lot longer than it would take someone who knows the system in and out, and I’ll grant that. I am absolutely the strongest on POSIX/UNIX-family systems. But that doesn’t stop me from being able to learn it and handle it. Even if it does take longer.

The difference between me and the unidentified person in my last post? I’ll spend any resources necessary—time, money, effort—to learn what I need to learn to get the job done. I don’t cut corners. My goal isn’t to get everything done sloppy and fast. Even if it takes me longer, I’d rather know and understand the problem—and its solution!—completely before moving forward with doing anything about it. Especially if I can find a short-term workaround that will enable me to come up with a quality solution. I eschew willful ignorance in my field. Do you?

So, this is a pretty simple-sounding network, yes? It should be—it is just a handful of computer systems. However, there is a problem—a pretty large one, I think. There is very little in the way of either policy or convention on the network. Some users use their documents directory for storing their documents, others store their documents on their desktop, others somewhere differently altogether on the C drive, others on a network share in a public storage space. There are different versions of software on the various machines, more-or-less updated when someone thinks about it, I think.

This is a perfect scenario which shows why a business network should be centrally managed in some form. Note that I am not saying that each machine should be a bit-for-bit mirror image of the one next to it, though that is certainly a possibility. I think that people should be able to use their own choice of things like email client or Web browser software, because everyone is different. But when you have different client applications fulfilling a role on the individual workstations, you have to take a centralized approach to ensuring that things like the email is all backed up.

Furthermore, if you don’t take a centralized approach to backing up such data, it is very difficult to centralize the network storage. Think about adding a domain controller (that is Windows speak for a central server which handles authentication and authorization, as well as file and printer sharing and things like roaming profiles) to such a network. I expect that with multi-gigabyte mail files, things will be very slow at first—and that likely the only fix for them that is going to be viable in the long term is to centralize more infrastructure.

I am too tired to expand more on my thoughts on what I have learned and where it is heading, but the Reader’s Digest version of the point reads something like this: If you are a small to medium sized business, make sure that you have someone who is competent in both system and network administration, and make sure that they are a part of your business from day one. Like writing software, building up a technical infrastructure without careful thought and design is hazardous and comes with many hidden and unpredictable costs. It is best to head those things off right from the start; to delay only amplifies the cost of fixing the underlying problems and puts oneself in the position where fixing one issue can have a domino-like effect and create more new problems.

For my current situation, I think I am going to have to seriously re-think how this whole setup is done. What I do not yet know is how to quickly and efficiently bring things into shape. A bit of training and education may be required, and certainly the removal of a lot of unnecessarily-granted privileges on the workstations. That, too, should be something caught early-on: do not let every person in a business run with administrator privilege, unless they are an administrator (and even they should only run with administrator privilege when they are actually doing something that requires that privilege). If everyone is an administrator, there is little to no control on how things are done in a network, and it can get messy.

I have a lot more reading to do, as well.

Well, anyway, it is way past my bedtime.  Time for sleep.

The Free Software Foundation objected to UDI for various reasons. Mostly, I think, it was because they were afraid that people who are not them would choose to use drivers that were non-free. As I’ve written about before here, there are people who think that forcing people to use free software is somehow freedom—and I will not go into it in any great depth here, because I have done that in the past. Suffice it to say that forcing anything is not freedom; it cannot be freedom. So, the Free Software Foundation, I think, was really afraid that they would have to do more work to be able to stick to their own requirement of using 100% free software on their own computer systems. (And hey, Roy, if you’re reading—I’m not saying that the FSF is wrong, and I’m not putting myself in a position opposite of that of the FSF. I suspect you think so anyway, but hey, I just figured I would point that out.)

Even if the free software operating systems did not adopt the UDI specification, why didn’t proprietary operating systems? This is perhaps the most puzzling thing to me. It seems that in this event, none of the operating systems—free or proprietary—did what would have made sense. After all, even if only Apple and Microsoft adopted a common device driver specification, that would save a lot of time, effort, and improve user experience all the way around. Apple users would be able to use all the hardware that Microsoft users could use—and the inverse would also be true. The amount of time that device driver authors would have to spend writing and debugging driver code would go way down—free software driver authors would be able to write a driver once, for example, and all systems (including free software systems that chose to support the specification) would benefit.

I could see an objection of a driver specification that was binary-only. However, UDI was not—it mandated an ABI so that drivers that are built for a particular platform were binary-compatible with operating systems on the same platform, but it also mandated an API, so that drivers would be source compatible to any operating system that implemented the specification, on any platform. That by itself would seem to me to be positive motivation to hardware manufacturers to release the source code to drivers so that they can support operating systems that are on platforms that do not exist yet, or have not been considered (or have been considered to be nonviable or unsupported platforms).

So, I have to wonder why a common device driver specification was never implemented in various operating systems. It would seem to be a common sense thing, especially given that there are so many operating systems. It would make the coexistence of operating systems a lot easier, and it would promote choice. It might encourage bits of proprietary code on free software operating systems, but it would also enable people to drop the excuse that “free operating system x does not support device y”, and would as a result potentially increase the number of free software programs and operating systems in use, even if there is a minor cost in terms of certain drivers. And those drivers could always be replaced—a common driver specification would make it easier to understand the structure of drivers generally, and make it easier for lawful, clean-room reverse engineering to be done on those drivers.

Imagine, for example, if drivers for graphics cards, TV tuner cards, video and audio encoding/decoding cards, modems, storage chipsets, motherboard chipsets, USB chipsets, IEEE-1394 chipsets, graphics tablet devices, touch screens, debugging interfaces, network devices, and so forth were all written to a common specification, it would reduce the amount of code which needed testing. It would increase user choice in both hardware and operating systems—something which I still hold is quite likely the most valuable freedom we have. It would increase reliability, since the users of Windows, OS X, Linux, the various BSD systems, and other, not-so-mainstream operating systems would be able to run the same driver code and collectively supply debugging information and perform testing in a multitude of environments. It would increase security, because then common code that is well-known could be used on all platforms and not just the one it was written for. It would do for device drivers what POSIX has done for user-mode application software. I do not believe that I could be convinced that this would be anything other than a good thing.

Also, it could bring back old operating systems.  Imagine what life could be like, for example, if OS/2 had a “UDI driver” written for it, and it could then take advantage of newer drivers never intended for it. Or any other very old operating system which is no longer supported and could still be useful, for any of a number of reasons…

I was still feeling rather off this weekend, and so I didn’t make it to this year’s Atlanta Linux Fest.  That made me quite sad.  Come hell or high water, I’m going next year, seriously.  Well, unless I’m sick again, of course, but what are the chances of that happening two years in a row?  Maybe I oughtn’t tempt fate by asking that question.  Oh, well, I did.

Also:  the weather here is fscking crazy.  I don’t know what is up with all of this weather, but we’ve had more rain in the past couple of weeks than we have had in a year or so, in some (if not most) areas.  Lots of things are closed, including schools, businesses, government offices, and roads.  And many people aren’t staying in their homes, and given the nature of the regular climate here, probably did not have insurance against flooding, so they probably are out most everything.  I can only imagine what that must be like, and I don’t envy those that are looking at that situation.

As far as other things go, I should be able to start working on things again relatively soon, after things return to something that somewhat resembles normalcy.  We’ll see about that.  For now, though, I need to go sit with Mr. Benjamin and hope that he drinks something soon and falls asleep soon after that…

Many projects that are all about being open and transparent provide mechanisms for their users to get in touch with the developers.  Launchpad has become an excellent place to do these things; Launchpad’s Answers and Bugs components are truly excellent ways to get in touch with people that manage software there.  The system is so good that I’d advocate that every project try to move to it.  Launchpad does have its issues, though they are often quickly fixed (and can be fixed even quicker now that it is free software).  But between Bazaar (a truly amazing and flexible distributed version control system) for code hosting and the other components of Launchpad such as the Answers, Bugs, and Translations components, Launchpad provides virtually everything that a project needs to communicate effectively with its users aside from the project’s Web site.  And users seem to naturally be able to reach out using it.

In the nearly one year that I’ve been working with AllTray, I’ve talked—well, written to—several people who have asked questions and acted in their own ways to work to improve the software.  Development on AllTray has been made much easier just because people are willing to speak up.  Everything from the random “thank you” to “hey, are you going to do this?” or “I’d like to see feature x in the new version” or whatever.  It’s truly great.  I can’t say that every project has users quite like AllTray’s, because AllTray is something of a niche application, but AllTray’s users are a great model for other projects.  There has been virtually no negativity from users and everything has been constructive.

To anyone who manages a project that doesn’t use Launchpad, I’d strongly encourage them to do so.  Its users are great, and as far as management of the overall project goes, it’s very easy for project people to communicate back and manage communications in a single spot.  It’s also great that users can ask a question and that the project can do things like go, “oh, hey, this is really a bug,” or vice versa with bugs→questions.  And if you don’t use Launchpad because you don’t want to use Bazaar (I hear that users of git are pretty dedicated to it; I can understand that, but it’s just not for me—it’s too complex, and I like that Bazaar just stays out of my way), consider using LP for everything but code hosting.  Or consider using Launchpad’s code hosting to mirror your project from git, it does this quite nicely.  Or, find some way to do what Launchpad does wherever you do project management.  It works really well, and it’s a big help.

And to AllTray’s users. A big Thank You.  You guys and gals are great.  Keep communicating!

Disclaimer: The math in this post is quick, back-of-a-paper math. It may contain errors; if so, please let me know. Also, bear in mind that I am not talking about net data transfers here, I am also including protocol overhead for TCP/IP and PPP where relevant, which is part of the reason why the numbers will seem so large in a few situations. Feel free to verify the math, though.

I decided to take a look at what kind of transfers I have effected since the last time my router was rebooted. Here’s the raw data (I am pretty sure that the numbers reported by ifconfig count things like retries and the like as well as protocol overhead for TCP/IP, but I am not 100% positive on that—I’ll go ahead and make that assumption for the moment):

Saturday, 2008-Aug-30 at 13:55:01 - mbt@zest - Linux v2.6.24
Ubuntu Hardy:[0-16/698-0]:~> ssh allspice 'uptime && /sbin/ifconfig inet0|grep "RX bytes"'
 13:58:34 up 44 days,  4:52,  5 users,  load average: 0.00, 0.00, 0.00
          RX bytes:91387801756 (85.1 GB)  TX bytes:51854749824 (48.2 GB)

This shows that my box has been up for 63,652 minutes, and has transferred in that time a whopping 143,242,551,580 bytes in that time. This is an average of 2,250,401.43 bytes (2,197.66 KiB, 2.15 MiB) per minute that the connection is up. For a 30-day month with no leap seconds or minutes, this means that in 30 days, the average transfer would be somewhere in the area of 97,217,341,611.51 bytes (94938810.17 KiB, 92,713.68 MiB, 90.54 GiB). In other words, about 36.21% of the threshold that Comcast is talking about. And this has actually been a rather light period of Internet usage for us—I have taken no snapshots of large projects on the Internet during this period, nor have I mirrored the Hardy repositories yet (I like to keep a local mirror on my server, and keep it up-to-date, when I can, so that I can install new systems without running out for updates), nor have I downloaded any other large data this month. This is just regular, every-day usage for us.

Out of all of that, most of the transfer is probably mine. I sit in several IRC channels all the time, I occasionally play Guild Wars (and even that, well, that’s not factored into this, because I’ve only played it once and I haven’t downloaded the entire world yet, because I haven’t been into it for a long time and didn’t have a local copy when I installed it again), I pull source code for packages when I am working on them, and so forth. I use a lot of bandwidth, and it’s not for commercial purposes.

Now, something else to think about before going further: Comcast claims that the limit will be 250 GB, not 250 GiB. In other words, 250×1000^3, not 250×1024^3, which is the series of measurements that I use. Converting my 97,217,341,611.51 estimated monthly usage, this results in a figure of 97.21 GB out of an allowed 250 GB (38.89%, not 36.21% as computed above). This assumes that they’re being accurate in the first place. Since I can’t be 100% sure either way, being that there is so much confusion of computer size measurements out there these days, I’ll assume that they’re using powers of 10 instead of powers of 2 for size computation, since this means that I will err on the side of safety.

So, I estimate that we chew through approximately 40% of their quota per month. What do I run on my home network? I have an Asterisk server, which routes all of my calls to multiple extensions (everyone should have their own PBX, it makes life really easy!), which uses VoIP. It doesn’t see that much in the way of usage, so it’s a small player. I do a lot of file transfers between the Internet and here, both over IPv4 and IPv6. Some of the overhead in our network usage is actually that from using an IPv6 tunnel to Hurricane Electric, though I am not sure just how much overhead there is compared to IPv4 directly over the existing Internet infrastructure.

These numbers are pretty awesome to me, given that once upon a time, I had a link to the Internet that was easily measured in bits per second.

In any event, if Comcast wants to limit everyone residentially to 250 GB per month of transfers, why don’t they have their accounts set that way? The account that I have currently has 8 Mbps downstream and 1 Mbps upstream; 9Mbps total. Assuming a 30-day, zero-leap minute/second month (IOW, each day is 86,400 seconds, and there are 30 of those, for a total of 2,592,000 seconds per month), this means that I can transfer up to 23,328,000 Mbits in a single month—which works out to 186,624,000 MB, or 182,250 GB. In order to bring that number down to 250 GB per month, I would have to be limited to transferring 32,000 Mbit per month, or 0.0123456790 Mbps aggregate in both directions—a whopping total of 12.64 Kbps. Yes, you could transfer more data than that on a dial-up connection in a one month span. In comparison, a half-duplex 28,800 kbps modem can transfer up to 37324800000 Kbits, 37324800 Mbits, or about 4,665.6 GB per month, assuming steady, synchronous, error-free data transfer and a damn good phone line.

In effect, Comcast wants for its users to have less impact on its network than a dialup user would have, to say nothing of 38,400 kbps modems or better. Now, the reality of a 28,800 kbps modem is slightly different, being that connections over phone lines tend to suck, and so there are errors introduced in the bitstream between the modems, which lowers the effective bitrate of the connection while retries are made at the link layer. However, to bring that 4,665.6 GB down to 250 GB, 94.64% would be the approximate rate of error—way more than I think anyone would tolerate unless they absolutely had to.

Now, that having been said, the real data transfer is always less. These numbers are assuming that the underlying protocols’ overhead (e.g., TCP/IP on Ethernet, PPP and TCP/IP on dialup) are factored into the data transfer rates. But, those would be considered to be measured as part of the link anyway, since that is data that is being transferred. I am not saying that you can download a 9,331 MB file on a dialup connection in a month, just that that much data would be transferred if the link were constantly saturated.

Is this a reasonable limitation? Hell, no it’s not.

We’re moving into times where everything takes place online. Computers aren’t really used as standalone machines anymore—a lot of online communication is tied to services, and those services communicate a lot of data. Email, Usenet, and IM are all technologies which permit people to communicate with each other, but for some time now, we’ve had systems that communicate with each other, as well. if you want the weather, you get that from an online service. If you want news, you can get that from an online service. Presence notification, and other things, are not things that humans directly communicate to each other; these are types of communications that are computer-to-computer, on a human’s behalf. When I go away, everyone gets a notification of that event when they are signed on to an instant messaging service that I use and they have me on their roster/buddy list. That’s a sizeable chunk of data if a lot of people are watching you.

Add to this the fact that we watch video streams online—and video streams are not lightweight things—and listen to things like Internet Radio, and other types of data transfer which weren’t possible even 15 years ago on a wide scale, and you can begin to see the problem. I don’t listen to Internet Radio all the time; I only listen about 10 hours a week. The stream is 128Kbps MP3, and for one 128Kbps MP3 I have which is 5 minutes 56 seconds, the file size is 5,707,152 bytes. MP3 is a frame-based format, and is easily streamed from any point in the file, making it not dependent on having to read a header. This particular file has no metadata in it, so it should be a decent sample to use. The file size if it were a 10 hour file, then, would be in the ballpark of 577,127,730 bytes, or 0.577 GB. For a month which averages 4¼ weeks, that means 2.446 GB just for the stream. Make that stream last the entire month, and it will be 41,553,196,584 bytes, or 41.553 GB. Add in TCP/IP overhead, which is 40 bytes for every 1460 bytes in the stream (and there are 28,461,094 such chunks in a month-long MP3) and you have 1,138,443,742 bytes of protocol overhead, for a total of approximately 42,691,640,326 bytes transferred for each person that listens to an Internet Radio stream for the entire month. 3 of us makes that potentially 128,074,920,978 bytes, about 128.07 GB. With a 250 GB cap, that’s over 50% of it, right there. Add that to our 97.21 GB figure from earlier, and that’s a total of 225.28 GB. Damn close to the limit. And if Comcast were to use “creative math” in determining the figures, that could be over the limit. Depends on what they include, if they include data overhead from the CPE, and so forth that I cannot possibly begin to account for.

In short, 250 GB is NOT a reasonable limit. Even less so, if you are a household with more than one person in it. So, what do I have to do? Program my routing, NATting server so that it notifies me when/if we do get close, because it is entirely within the realm of possibility, and force us to be disconnected if we get too close to the limit. They should cut our bill by 75% for this, and even that wouldn’t be enough—250 GB of transfer, in 2008? That’s just cheap.

(Even when you can see that it’s worn toner, and you can see that the letter hasn’t been altered. Surely, technical types cannot be the only people that can see that.)

Oh, well, whatever. Anything in the name of national security, right?

It can be done; one just has to remember that a “fundie” (the variant of the word which makes the malicious connotation clear) is someone that exists at a special place called the end of the spectrum. You can have a fundie of religion, or a fundie of operating systems, or a fundie of text editors. (Hey, we get all of those and more in the Unix world! Then again, you get them in the real world, and the Microsoft world, and just about everywhere you can go—online or in the meatspace.)

“Fundies” are all about being on one end of the spectrum or the other. You can’t argue that fundies have to be Christian fundies, because that makes just as much sense as it would make to call Roy Schestowitz an anti-Novell “fundie”. There is nothing fundamentalist about an operating system or a religion, no matter how many people believe that $RELIGION was the first around, the longest lasting, the One True Thing. We all have a tendency to have biased thoughts like that about our favorite deities, religions, operating systems, or text editors. And the term “fundie” applies to those who have such a bias, that they cannot see anything else in the domain of the conversation.

Think about Socrates Meets Jesus, wherein Socrates and Jesus Christ have a dialog which goes in circles in avoidance of anything concrete. Much the same can be found in any religion: there simply isn’t much that is concrete about it. (People will argue that spirituality is the thing that religion tries to access, though I’d tend to disagree, since most people that try to sell “spirituality” are also selling “religion”.)

That having been said, each member of each religion can all claim that their religion is the one that is fundamental to the existence of the world and all of creation, and so it is necessary to get that none of it is fundamental (because all of them cannot be fundamental, for they are all different things). Furthermore, it’s obvious that an operating system, a text editor, and a programming language which exist today cannot be considered to be fundamental; even the “fundamental language” of computing (the binary number system) can be considered to not be fundamental, since the world existed way before we figured out different based numbering systems.

Much like Asimov’s first usage of the word “fundie”, at which point the word did not yet have a definition. It is adaptable, too, though the dictionaries (and even Wikipedia) are a bit behind on the usage of the word “fundie” to refer to anything other than Christians.

Just read another post that was interesting to me. This article was about how Linux is bloated.

“Bloated? Linux?” Yeah, well, most modern software is bloated, and it is rather sad. Now, that having been said, he was talking about a distribution, but his point is extremely valid: Today’s programming “environment” is very much so bloated. Part of this is that we use languages that are expressive, duck-typed, and perform a lot of things behind the scenes for us. An example of that—as mentioned in the linked-to post—is Python. Python makes writing scripts and converters and other things very quick and easy, at the cost of increased memory and processor usage.

This isn’t a bad thing, per sé, but Python is used heavily in a lot of systems today for application software and system configuration utilities and things where it probably shouldn’t be used. It could be worse, but that’s no reason for things to be the way that they are presently. It seems that Python’s place in the system really ought to be to prototype nice ideas, and then, after the prototype is complete and accepted, re-written in a language such as C++ or even C#. (“C#‽ Isn’t that bloated, too?” Well, yes, but in a different way. C++ is good, though, if you need object-oriented things.)

There is a definite trend of moving away from compiled software, though. I am not sure if this is a good thing, or a bad thing. Of course, processors and the available memory of systems will increase as time moves forward, but why should base software be so hungry and depend on that? I remember when I was using a desktop that had 8 MB of RAM, a 66 MHz processor, and only 200 MB for storage, and I could do a great deal with it, and it was pretty snappy. Today, of course, I’d not be able to install a basic system into that space, and I shudder to think how (non!) responsive today’s GNOME would be on such a system.

What should the answer to this be? Is there a way that we can use software that is easy to develop, and not have the massive amounts of overhead that are often attributed to interpreted and byte-compiled software? How could we take advantage of that? After all, we have things like shared libraries that let us load an often-used library only once in system RAM, which should mean that we have decreased memory usage and increased performance, right? Well, sort of. But today lots of applications distribute their own, private copies of shared libraries for one reason or another, and so it makes it hard to determine how much an application’s real footprint in memory is.

So, the real question is this: With the availability of a runtime that can host (nearly) any language, and apparently is even able to host an operating system (anyone read about/tried Microsoft Singularity or SharpOS?), what about creating a Unix-like system using this technology, and making even more aggressive use of memory pooling between applications? Would this maybe be enough to combat the bloat that comes with extremely flexible and feature-rich programming languages and class libraries, maybe?

Or are we stuck moving forward into a world where the hardware and the software are both bigger than they used to be yesteryear?

I used to think that language features found in the C family—notably, strongly typed variables—were nothing but a painful nuisance. At least, I thought that way until probably a few weeks ago, when I started work on a PHP project after spending a lot of time working in Java for a class and C# out of my own interests. And I realized something about languages that use strong variable types: Languages that require strong typing of variables might be inconvenient sometimes, but they build a lot more documentation into the program, simply by requiring strong typing. In a language such as PHP, you simply cannot tell what the variable’s type is by looking at the variable name. If you follow conventions (and not all people do) for naming your variables, you might be able to create little “hints” to their types, like $isAuthenticated for a boolean value or $startedWhen for a timestamp, date, time, or other similar type. The Hungarian notation might work for PHP, too, but I have always found that rather hard to read, particularly in certain situations. Instead, properly written code in a strongly typed language makes it very clear what the variable is, does, and may contain. Very fascinating at least to me, simply because I have always disliked what I perceived to be inflexibility in strong data types for variables.

Of course, this isn’t the only reason that I am finding I would want to work with one of those two languages. I absolutely love the idea of generics (yes, I know that they’re in C++… I never did play with that language enough to “get it,” apparently). I like the simple power of the languages (and their associated class libraries)—you can do things like create a dynamically sized array in a way that feels natural and non-hackish, using a type of generic called a “collection”, which goes a long way towards readability (and as strange as it sounds, that power partly comes from the extra documentation provided by the strong types used with them). Given that “code is read much more often than it is written”, it makes sense that features that reduce the amount of programmer time like this—and are readable—are things that I find useful.

There is only one real downside to both C# and Java, when compared to a language like C: They are far, far slower. What they essentially do is transfer programmer time to system processing time—depending on an application’s lifecycle combined with many applications running at the same time on a system, the system processing time could indeed be more than the time a programmer saved writing the program to begin with. C# tries to mitigate this by compiling the program’s bytecode “just-in-time” so that native code runs, and code that executes repeatedly gets a benefit from this. Java does the same thing with HotSpot, though only in certain areas of a program as the Java VM figures is necessary while analyzing the program during its execution. Still, they are slower and use more memory. PHP probably is, compared to C, as well. I think it would be interesting to compare PHP against C# and Java in a Web environment, though I have not done that just yet since there is no really easy way to do it equitably that I am aware of.

Anyway, how does this pertain to Web programming? I am beginning to think that I should use PHP for only small things that are not required to be very powerful or have long maintenance lifecycles. Why? There’s a ton of PHP programmers out there, to be sure, and PHP runs “out of the box” on a lot of services, such as NearlyFreeSpeech.NET, whereas something like mod_mono or Tomcat do not. You might be required to manage more of an application server with the latter choices, while the former ones are more flexible in most installations and you can manage just the application and leave the server management to a crew of people that want to do that. Where, then, is the benefit?

It would appear—at least to me—that the increased investment in initially setting up a Web application server (and maintaining it) with an environment for either C# or Java would be paid off in that wonderfully limited resource known as programmer time—as well as frustration. Personally, I hate re-inventing the wheel. And while there are resources for PHP that will let you do that, sometimes they require extensions to be installed or—often—the use of ad-hoc class libraries written for PHP, such as those found at the PHP Classes Web site (which, IMHO, is a poorly designed site to begin with). Unlike PHP, C# and Java both come with very large, powerful, and more importantly, standard class libraries, which is something that greatly helps programmers with both reading and writing code. There is a lot of support out there for using third-party class libraries (which you can find all over the place), and they are supported by a lot of third-party programs with interfaces, too (such as MySQL and PostgreSQL, and others).

All told, learning these languages has got me wondering if I shouldn’t use one of these languages instead. While I’ve really only scratched the surface of learning about many of the other things (such as the details about creating Web applications in these languages and hosting them), it seems that overall, there are less headaches to be had and code can be written faster, debugged faster and more efficiently, and there is more convention built into the language to govern how things are read and written by other people.