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?

I am sure that there are people who do this in every single line of work. But what disgusts me more than anything is someone who thinks that just because they did something like served in the military or got a degree of some sort that they know everything and that everyone else has to prove that they have two brain cells to rub together. Do you know what someone with a Ph.D. is good at? Marketing. They have to be.

You know what I hate with a passion? Marketing. Because most of the time it is hogwash.

What prompts this, you might wonder?

So today, I responded to an unexpected downtime call. Long story short (because details cannot be given out, for obvious reasons), this meant that I got up out of bed to answer it. No problem; it’s what I do. I go, I handle the problem, I encounter a couple of snags, find that I no longer have authorization to fix those snags, and go on about my day, providing a notification of the issues that I wasn’t able to fix—and why. As far as the “fix”, I had to switch to a backup connection on a mixed voice/data T1 (technically, DS1, but nobody calls it that except the engineers, I am pretty sure). No big deal; the equipment is setup to handle that, and it works just fine, albeit slower than anyone would like it to.

Enter Fatuous. Fatuous is someone who is employed as an “Information Technology” support person. Of course, that is not its real name, but it is suitable nonetheless.

Fatuous sends an email to the effect of “you cannot run data through the T1 because it will make voice calls suffer”. Let’s keep in mind here that this particular equipment does both voice and data, and it gives preference to voice calls. In other words, if all the circuits are busy handling voice calls, there is no more room for bandwidth. Sounds simple, right? It should, because it is.

So, I explain this little fact, and I get a mail back—oh, yeah, and half the office is needlessly carbon copied on this. Great! Let us fill everyone’s inboxes with a bunch of technical jargon that they will not care to read and (probably) have no desire to understand. Well, whatever. So the mail basically says, “Cite something, you’re wrong.” Wait a minute, what? Fatuous seriously does not understand what a T1 is. Now, if you have worked in the IT industry for any period of time, even if you have never used one, you should really know what a T1 is. Especially if you are over the age of, say, 25 or 30. Particularly if you are over the age of 40, since it is quite likely that’s what they were using for high-speed interlinks then (nevermind the fact that it is only a little bit faster than a low-end ARCNET card/network it was once considered high-speed connectivity, just as ARCNET was).

Fine, so I explain what this means in a high-level, cursory overview that hopefully had words small enough for Fatuous to understand. In the meantime, I am raving mad. I have dealt with Fatuous enough that it is readily apparent that there is no salvation here: its ignorance is willfully incurable, and that is terribly sad. I am not sure what is worse: the fact that it has a job doing something I am way overqualified for, or the fact that it has a job doing something that I am way overqualified for and makes a fuck of a lot more money than I do.

Sometimes, I really hate the universe.

First point: FatELF would be useless because “you can do that already, write a cc frontend that compiles the same file multiple times, it’s _not_ hard, I’ve done it before“. Okay, so the proposed solution here is to write a compiler driver that will interpret arguments and, from a single Makefile, build for multiple platforms. There might even be something out there for that, but simply put, if GCC supported this feature intrinsically, then everyone would have it and it would be done in a standard way. Free software works better when everyone can agree on a single standard way of doing things, and not just a single standard template for how it might be done. Using addons to perform this function still yields multiple binaries that have to be shipped anyway, which is decidedly not the aim.

Second point: “how is shipping one (fat) binary ‘better’ than shipping one auto-extracting auto-deciding archive?” Making the assumption that the toolchain and kernel all support the feature as a standard thing here, the difference is simple: the kernel ELF loader would be able to decide which sections of the ELF file should actually be loaded in memory, read only those sections, and go on about its business normally—the rest of the process would not need to change in any way. No temporary copies need to be made, no images need to be extracted, nothing like that has to be done. However, the inverse is quite a different story. Let’s make the assumption that you’re using a POSIX shell script, with the archive of all of the possible binaries appended to the POSIX shell script. First, the script has to be prepended to EVERY such archive (meaning that different versions of the script could exist, and as any programmer knows, DRY), and the script is not going to be trivial: it would have to have code to detect and support every single individual platform. Furthermore, it would require that the user have permission to extract the payload, make it executable, and run it. This is the same deficiency that makes gzexe impractical for everyday use; I know that at least on all the servers that I manage, /tmp is mounted read-write but with execution of scripts and binaries disabled. Finally, it would fail to properly work in the event that something needed to be setuid—that information would have to be in the payload itself, which is absolutely not portable from one system to another. It just cannot be made to work in a generic enough fashion to be reliable on all different types of platforms with different administrative decisions made in the management of those platforms, and in many cases would require an increased attack surface just to be made workable.

However, if FatELF (or, honestly, anything that is truly equivalent) were used, an administrator could copy the binary from one system (say, an x86) to another system (say, a PowerPC) that has all of the other dependencies filled for it, drop it on the filesystem, chown/chmod it once, and it would Just Work. setuid, if needed, would be honored by the kernel, and no extraction has to take place. No additional temporary disk space would be required, nor would it be necessary to incorporate any logic into the ad-hoc “loader” (if it could even be called that) to try to find a filesystem that is read-write with execution permitted for the current user, and therefore no special privileges from the user would be necessary.

In fact, the only way to solve the problem reliably at present would be to have something like /var/cache/adhoc-fat-binaries, and have all ad-hoc “fat binaries” be setuid 0 (or setuid to some user that has all necessary privileges to make something setuid 0 if necessary, probably only UID 0 has that privilege on most systems) so that it could (a) write to /var/cache/adhoc-fat-binaries and (b) set the setuid or setgid bits if necessary for the program to fulfill its function. And it deserves to be restated: we all know that having a single specific standard and adhering to it—even when the standard is less than ideal (and in some cases, like X11, falls quite short of ideal)—is far better than having 100 different and incompatible ways to do the same thing. It’s one of the things that we people in free software know pretty damn well.

See, I don’t see something like FatELF being used for distribution binaries, or anything that would be distributed in an operating system distribution package, except perhaps in special situations where something like biarch is natively supported on the hardware and it would be feasible to permit that sort of flexibility. Instead, I see something like my current situation: I administer several machines for small businesses, and not all of them are the same hardware platform.  They are all the same operating system and many of them have the same libraries installed.  Some of them are 64-bit and some are 32-bit.  Some are x86, some x86-64, and some are neither. But I would very much like to write a single program, say “make” and copy the file to every machine so that it just works. For the moment, if I want something like that, I have to just use something like Java, C#, or a script. Or, if I need something setuid, I do it in C and compile it for every system, shipping the source code file to the systems instead. But it would be more efficient to not have to do that. That is why I would see FatELF being a “good thing”.

I know that I am in the minority.

That brings me to point three: “because in 99% of all usage, the kernel won’t _need_ it. And its cost in effort and overhead would be higher.” For this next part of my post here, I am going to be looking at the Linux kernel, version 2.6.34, which I have just downloaded from kernel.org, which is 64 MB compressed (using bzip2!) and takes up 442 MB when uncompressed, before touching any file in the tree. Now, I am looking at this for x86-64 because that is the system I am running on and typed “make menuconfig”.

Who needs any of the following options? I am willing to bet that the following options are not needed in 99% of all (desktop, server, and embedded, combined) usage:

1. Processor type and features/Support for extended (non-PC) x86 platforms
2. Processor type and features/Maximum number of CPUs
3. Processor type and features/Memory model
4. Processor type and features/Build a relocatable kernel
5. Executable file formats / Emulations/Kernel support for ELF binaries
6. Executable file formats / Emulations/Kernel support for MISC binaries
7. Executable file formats / Emulations/IA32 Emulation
8. Executable file formats / Emulations/IA32 Emulation/IA32 a.out support
9. Networking support/Plan 9 Resource Sharing Support (9P2000) (Experimental)
10. File systems/Second extended fs support
11. File systems/Reiserfs support
12. File systems/JFS filesystem support
13. File systems/XFS filesystem support
14. File systems/GFS2 file system support
15. File systems/OCFS2 file system support
16. File systems/Dnotify support
17. File systems/Kernel automounter support
18. File systems/Kernel automounter version 4 support (also supports v3)
19. File systems/FUSE (Filesystem in Userspace) support
20. File systems/FUSE (Filesystem in Userspace) support/Character device in Userpace support

I can’t even go on. Twenty is enough; I think I have made my point. In 99%+ of all situations, these options are either always on or always off. They are rarely modified. And the kernel still supports a.out from IA32’s really old days‽ Seriously?

What does this tell me? It tells me that FatELF—or anything else that came along and did something like what FatELF would do—has room in the kernel. And if it were for whatever reason incompatible with current ELF (as it would very likely be) then the kernel could still support “old” ELF, without any of the extra fields or sections.

And actually, there is a great deal of possibility around something entirely different altogether. FatELF isn’t the most technically elegant thing I can think of to solve the problems that it solves, but I have yet to see something else seriously proposed. I can think of something even better, actually. We are all taught that operating systems are here to abstract us from hardware, so that we can write applications and not have to worry about communicating with the hardware directly because the OS handles those details for us. Well, if that is the case, then why don’t operating systems also abstract the system’s processor? Why don’t we have operating system kernels that provide a virtual instruction set? Yes, I am talking about essentially moving the application VM into an operating system kernel, though ideally with some supporting utilities in userspace to do things like hold persistent JIT caches and so forth. However, that’s for another post, another time.

Yes, it is true that Canonical has not given up the source code for the U1 server-side software. And if you stop right there and proceed no further down the train of thought, you will probably come to the conclusion that it is proprietary software—and you would be wrong. Why?

Because the U1 client is free software, that’s why! It seems to me that we have forgotten what client/server applications are. Remember that HTTP is a client/server application, as is SSH, as are so many other types of things. It doesn’t matter if both sides have source code available, when it comes to client-server stuff. In fact, it almost doesn’t matter if the server side is available, because by itself it is useless. However, if the client source code is available, that tells you a great deal: it says, “here is how to talk to the server, how to communicate with the server, and how to use the server’s facilities in code that is useful,” and from that you can create an interface. Once you understand the interface, you need only to write software that fulfills that interface, and voilà, you have yourself a free software server that satisfies the client’s needs.

Then all you have to do is point the client to the new server software, installed somewhere on a server that you control, and you are all set. For that matter, I am somewhat surprised that nobody has done this just yet, because it seems to me that this would be a most excellent means to doing synchronization on systems in an office/workgroup setting. You could then set the Ubuntu One client to point to a server of your choosing and tell it, “sync all of the ~ directory” or “Sync all of ~/Documents” or whatever on every machine and you would have the ability to share and so forth… overall it seems like a great idea to me. Too bad I don’t have enough time to write it currently, though; I have a full plate of other projects (both in the realm of computing and not) that I have to get done first.

Unless, that is, someone wants to offer me some serious cash to write an U1 server implementation. Cash always advances a project to the head of the queue…

First, let me start by saying that you should read this Ars Technica article on “The prospects of Microsoft Word in the wiki-based world” which is a great article on how unnecessary something like a word processor is in today’s world.  The article is nearly a year old, but it’s still a good read.

Creating information from data does take some work and that work should go somewhere. A wiki seems a natural choice: everyone in a workgroup can collaborate using a wiki, and the data from the wiki is all in a single place so that it can be easily backed up. Of course, it takes some getting used to the notion that you are using a wiki and not a word processor, but that’s not all bad.

Most things that you work on in a word processor these days are done only to send to someone else in an email anyway. And word processors do not guarantee that formatting is kept intact unless you send in a strong, font-embeddable format such as PDF anyway, so they have little point. At least with a wiki, you have the ability to quickly write and save, and others can come along and update, and so forth. If you need to, you can even upload things that people send you (graphics, documents, whatever) into the wiki and use the wiki to keep track of those things.

In fact, I sometimes wonder why we don’t actually use things like wikis for information storage and retrieval more frequently. After all, once upon a time, a folder that held paper was an acceptable form of record keeping. The analog to that is a folder with text documents located in a filing cabinet, or a wiki (the cabinet) with articles and hierarchies (folders and files). Then you can have files that are as long as you need them to be without actually having to worry about how much physical space they take up. With the recent apparent movements from structured databases to unstructured information storage systems, that seems to make sense to me. At least then you’re still using a solid database that performs well, but instead of using a highly inflexible database schema that is application-specific, you can use the wiki instead.

Well, anyway, just a few of my thoughts—2¢ worth of them anyway. Back to my regularly scheduled day, which today involves reading source code from the Mozilla project.

For that matter, I am like, way behind in reading blogs around the Internet.  Oh, dear.  And I don’t think that I am anywhere close to being able to actually take the time that’s necessary to catch up.  Moving into a house has taken up more time and money for the initial setup than I imagined it ever would.  Conceptually, it seems so simple: buy house, move stuff, done.  Of course, it never works that way.

I have my computer workstation setup, and usable, for the first time in almost (over?) a half a year.  Oh it’s nice to be back on zest.  Of course, I need to actually update all of the contents of its hard drive being that I haven’t used it in half a year, so I’m busy getting old stuff shoved onto BD-R discs in case I need to use the stuff at some future date and then I am going to wipe the system clean for the first time in probably two or three years and do a fully clean install of Ubuntu.  I am hoping that it will fix any of the lingering issues that I have with the sound system—I can’t believe that it’s 2010 and we still can’t do 5.1 channel surround correctly!  I have the 5 channels, but not the .1!  Well, I have the .1, but with next to no volume; it might as well not be transmitting any signal to the LFE channel for the subwoofer, because in order to hear the sub at all I have to make the other speakers painfully loud.

Perhaps the biggest thing I have missed about not being able to have a proper workstation setup is the chair.  No, the keyboard at a comfortable height, for which my wrists will (I hope!) be grateful.  Or maybe it’s the regular use of two monitors at the same time on the same system.  Hell, I don’t know what the biggest thing is.  Maybe it’s that I have a roomy system again.  Or maybe the fact that I can now get back into a groove where I can keep references on a screen while I am working with programming and so forth.  There’s nothing I hate more than having to refer to some silly reference and have to flip full-screen windows or virtual desktops to do it—that’s something that two monitors makes very easy, because then I can work in one and have reference information in another.  Too bad I don’t have room for three monitors, because I’d totally use all three of them.

I jokingly mentioned to a friend of mine on the phone today that I have four display ports on the back of my computer, and I have four monitors laying around, maybe I should try to use them all… but I know that (for the short time that I had 3 monitors, anyway) that it was a joy to use and improved my ability to work much like when I originally went from one monitor to two monitors.  I wonder, seriously: what’s the largest number of monitors that makes sense for productivity?

Well, anyway.  I have to wrap things up and get to bed.  It’s nice to type for a bit, though, even if I have not written frequently enough that it’s no longer likely that there’s anyone left to read it.

Tomorrow’s list: get one more lock set installed (we forgot a door—how did we do that‽) and start getting some of the minor things that we can do taken care of, such as replacing the ancient thermostat that is in there with a more accurate and efficient digital one which is programmable, fixing the stupid holes I made today, and trying to take an inventory of all the minor repairs that we are looking at having to do over the next year. Nothing there that is awful or time-critical, of course, but little annoying things, like a couple of the cracks that someone managed to put in the floor, replace various pieces of trim that have been broken, or fill in little holes here and there to even things out. Oh, and a toilet seat, three 9 volt batteries, and… something else I am forgetting.

Oh, well. Time for bed.

One of those situations where it is really annoying is when trying to do things that ought to be really simple. For example, when writing an accessor function for a boolean value, one would expect to be able to just do it, right? But because PHP isn’t anywhere close to a strongly, statically typed language, this is impossible to do simply. The programmer must be burdened with checking the types, or hope that the user will never make a mistake.

Some days I wonder why I’m not writing Web application software in C using SCGI…

We pay cash at restaurants especially ones of certain
nationalities.

The context of this quote is a discussion on credit/debit card usage, and this statement came at the tail end of how care must be taken to ensure that one is not subjected to fraudulent charges (nevermind the fact that banks in the U.S. mostly do zero-liability these days). This has spawned a rather heated discussion, which apparently resulted in the person who made that comment leaving the mailing list.  The whole idea that we continue to change our behavior depending on the ethnicity of the person(s) we are around is nothing short of infuriating. It is like we fail to understand that qualities like honesty and trustworthiness are markers of an individual.

What does the above statement say? It says that the poster of that statement feels that he cannot trust “certain nationalities”. This person later made the claim that it was sad that people could find racism in nearly any remark—but the thing is, it is right there, not even hidden from view. It’s blatant.

Even worse, when the poster of the comment above was called out on it, most of the people on the mailing list jumped to this person’s aid to defend them. Honestly, I do not know what is worse: the fact that this person said this in the first place, or the fact that the majority of the mailing list’s members rallied up on the side of that person. Quite possibly, I think the latter, because that shows that we still have in society the notion that racism is somehow acceptable, and that the more veiled or subtle it is, the more okay and polite it is. I find that downright offensive.

It is certainly enough to make me consider dropping the mailing list and participation in the group altogether. It is difficult to be in a group when you cannot even look at its members—your peers—with respect, even if they are some of the smartest minds you know in a particular field. Why be part of it at all?

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.