Telling the world about the genius of simplicity


Hackers: Innovators or Opportunists?

I turned in this essay in the spring 2013 semester in Expository Writing I (I am a CS student pursuing a bachelors degree), detailing the difference between the public concept of hackers, and the original vision, which began in the early 60′s. I post it here for your enjoyment.

Mention the word ‘hacker’ to most people, and it would be a good bet the first concept which springs to mind would be of a person who breaks into computer systems. It is little wonder this image persists in the mind of the general public, because it has been the one which has been championed by the media.  The popular concept is that of a programmer who ‘hacks into’ a computer system. Most of the time, it is to cause general mayhem; other times, the chaos follows a specific course.

    However, it may surprise the reader to know that malicious intent was not always associated with the hacker, and furthermore, much of the software we use today, and the infrastructure which utilizes it, was built by people who enjoy coming up with new ideas to solve problems. For example, the ARPANET, the predecessor to what we now know as the Internet, and Unix, both of which came into existence in 1969, were products of hackers. It is no secret among hackers, but little known by the general public, that Linux, the progeny of Unix, arose autonomously through collaboration between developers or groups of developers over the medium of the Internet, thereby flouting the common wisdom which held that collaboration could only occur locally.

    In her essay “The Hacker Ethic”, Sarah Granger explained this apparently contradictory term. She notes that “the ‘hacker ethic’ can be a peculiar concept to those unfamiliar with hacking and what [it] really is”. She goes on to say that “in fact, the entire definition of ‘hacking’ is somewhat obscure. Hacking originated as a challenge between programmers…Individuals would ‘hack at code’ meaning that they would work at programming problems until they could manipulate their computers into doing exactly what they wanted” . This captures the original meaning of the word ‘hacker’ precisely. The kinds of problems these people would face were original in nature, meaning there was no example code they could look at and adapt to their problem. In order to surmount this programming obstacle, the developer would have to know the computer extremely well.

    In 1961, when the term ‘hacker’ was first coined, computers were several magnitudes slower than a modern cell phone, big enough to fill the back of a room from wall to wall, and produced enough heat to require several tons of air conditioning; in the winter, the computer centers would not need to invest in a heating system at all.  They would pipe the heat from the computer room to the rest of the facility. Programming them was challenging, to say the least. It required that a programmer knew his computer hardware very well before he could write a program; these were the days before Intel pioneered the x86, a family of processors that are ubiquitous today, and every manufacturer, be it General Electric, Honeywell, Data General, or Digital Equipment Corporation, implemented their hardware in different ways, meaning that their computers, while performing essentially the same function, did them in very different ways. A program written for a DEC computer, for instance, could not be run on a GE computer, and a program for a DG computer could not be run on a Honeywell.

    If a programmer knew assembly language programming, he was considered merely adequate in the hacker community; if a programmer knew enough about the hardware of his computer and understood the problem well enough to be able to write the program small enough to tackle the task efficiently, he was good enough to be called a ‘hacker’. To be able to fully appreciate the significance of this accomplishment, some context is required. Computers in those days had memories which were measured in thousands of bytes, or characters. Modern computers routinely are fitted with a memory which is measured in billions of bytes. The computer on which I am writing this essay, for example, has a memory of 16 billion bytes, or gigabytes (GB). Computers can do a lot more today than they could in those days, but the tasks which they needed to do were much the same. Accordingly, some sacrifices needed to be made in terms of the way that a program presented itself to the user, received information from a user, processed that information, and stored the information.  

    Granger notes, “Several definitions for ‘hacker’ exist…1. A person who enjoys exploring the details of programmable systems and how to stretch their capabilities…8…A malicious meddler who tries to discover sensitive information by poking around…the hacker most referred to in general is the hacker in definition no.8, whereas most programmers refer to hackers by definition no. 1”. Tom Cross agrees, stating that “The general public often has difficulty drawing a line between hackers who study computer security as a technical interest, and criminals who break into computers and deliberately cause damage”. In their paper, the authors of “The Autotelic Propensity of Types of Hackers” report a finding by Steven Branigan, who claims that those who get into computers first, and then start hacking, are motivated by curiosity, whereas those who have criminal tendencies to begin with     and who later learn computer technology, figure out how to apply the technology to their trade. Thus two types of hackers have been identified: those motivated by education or curiosity, and those motivated by crime.
    Clearly, the answer to the question “What is a hacker?” is not so easily defined; it depends on the person for whom computers are more than a passing obsession. It is a part of our depraved nature for people who consider the world as their enemy, or just has a grievance with another, to find applying their knowledge of computers toward that end desirable. On the other hand, some people who find their social skills lacking, who enjoy working and thinking in great detail, or a combination of the two, but who otherwise harbor no ill will toward anyone, would find the computer as thrilling to express themselves on as a blank easel would be to an artist, or a word processor to an aspiring writer.  The two human types share an aspect in common: both of them find socializing rather challenging, and find a ready outlet for their passions on the computer. What, in my opinion, makes the hacker a criminal would be a person who, having perceived him or herself to be wronged, considers it a duty to right such wrongs. It is commonly known that ‘good news can’t make it across the street, but bad news travels the world.’ Hence the widely-held notion of the hacker as a malicious evildoer, whereas the more honorable and accurate definition, that of someone who enjoys using the computer to solve interesting problems, is known only to a few people.

    The authors of “The Autotelic Propensity of Types of Hackers”  state that “the word, autotelic, derives from the words for ‘the driving force from the individual him/herself,’ without concern for external rewards or punishments”.  Autotelism, while rarely used, is actually an accurate description of what drives a person to learn a machine which is horrendously complex; no person who does not think in detail would find learning how to operate a computer interesting, let alone be driven to learn the details of it. They note “individuals in an autotelic state are in a state of enjoyment where the individual forgets his or her troubles, has a sense of competency and control, and loses sense of time. In effect, the individual loses self-consciousness while perceiving a sense of control.” Most often, the hacker comes from a less than desirable background, and derives the same from a computer as another would from drugs; they are able to escape from their reality into a land of eternal bliss. Where the line between good hackers and bad hackers is drawn is that the good hacker, while troubled, does not have a desire to seek revenge for their being wronged upon the world (or society), whereas the bad hacker does. Every other factor is identical.

    In fact, there are some people who question whether having the knowledge of how computers work is wise at all, stating that “knowledge is itself dangerous, irrespective of the motives of the people discussing it”, as reported by Cross. What is apparent is that computers, while having been accepted as a field of study for several decades now, is still very little understood. The most common reaction of people to the unknown is fear; fear leads to all kinds of behavior which normally would not occur, such as drawing up laws to “protect” themselves from the dangers which arise from the people who know computers in great detail.

    Cross goes on to state, “Hackers believe that ethical questions generally apply to the application of knowledge rather [than] to the pursuit of knowledge…knowing how to do something that might be harmful is not the same as causing harm. Once you have knowledge you must decide what to do with it.”  One has to have the intent to do harm to another before the harm can take place. Knowledge merely enhances the method one chooses to accomplish the deed. Other fields of study, such as writing, mathematics, architecture, construction, music, sports, etc., are centuries older and much better understood than computers, which have only a few decades behind them.
    Cross argues that “hackers also believe that valuable new ideas do not always come from established institutions…it is widely understood that critical developments in computer science have come from garages and hobby clubs (most notably the Homebrew Computer Club, an early crucible of the personal computer revolution)”. This differentiates the “white hat” hackers, a commonly-used term for the good hackers, from the “black hat” hackers, some of whom believe that the only valuable information is locked up in a government institution, and it is their right to steal that information and expose it to the world.

    Cross ends his article with the statements, “Most important, hackers believe the pursuit of knowledge is an inalienable right, tied directly to freedom of speech…the history of the hacker community is filled with people who have faced significant personal consequences for revealing truths powerful interests sought to suppress”. While it is a known fact that good hackers do not actively seek information from the establishment, if they perceive that information which should be made public is being withheld by powerful people to the detriment of the public, the hackers will be relentless in their drive to ensure that the information will be published, even at the cost of their freedom.

    In the end, what are we to conclude about hackers? All of them are driven by an insatiable curiosity to learn more about the mysterious machine which is so little understood, but which simultaneously serves as an easel for those who are willing to take the time to paint a picture, much as a master artist learns his craft: the kind of paint he wants, the brushes, the way his hand sweeps across the easel as he expresses in vivid colors what he envisions in his mind. These people are learning their art in their spare time because, as David Bellin, in his essay, “High school hackers: heroes or criminals?” succinctly expresses it: “What’s going on in the schools if there’s no real learning about computers and no excitement in learning in school?”. Most of the older members of the educational system are comfortably ignorant about the complex machines on which so much of their lives depend; acknowledging that computers are essential to the way they conduct business, they would rather busy themselves with tasks which are more in their purview, such as biology, mathematics, or some field of science. Because of the constant barrage of the malicious type of hacker making his presence known, laws are drawn up to help bring these malcontents under some kind of control. Certainly, as Bellin states, “the politicians and government leaders find themselves with a handy emotional issue, one that is very exciting”. Politicians live and die by votes, and if these issues result in another term of office, so much the better. Because of the age of the article, the statement “We presently have a federal administration presently, which is emphasizing increased government controls on access to data”, most certainly refers to the Reagan era; nevertheless, the statement still holds true even today.

    Bellin’s concluding statement to his article is comprehensive: ” A parallel question has been ignored. Why aren’t we discussing criminalizing negligence on the part of computer center directors?  These are the experts who are supposed to know about computer security, who are supposed to run an operation in which unauthorized use cannot take place…If there is any criminality involved with unauthorized access to computer systems…the fault may well be in the negligence of computer center directors and the hypocrisy of our government leaders . “
    So very true. Even knowing full well that breaches are a real danger, the inconvenience of securing their networks properly is enough to lead some of our supposed experts to procrastinate in following established security procedures, leaving their networks wide open to attack.

    Granger makes mention of this in her report, stating that “the argument which a hacker who breaks into a system often uses is as follows: ‘If I can do it, and you have not taken the precautions to keep me out, then I cannot be held accountable for, nor punished for acts that have occurred because of your, or administrative/government omission or lack of safeguard’ ”.


Perhaps the best conclusion one can draw is that which was put forth by the authors of the article, “The Autotelic Propensity of Types of Hackers”, who state “because hacking is seen as an enjoyable activity by those in the hacking community, these individuals seek the enjoyment of hacking again and again, and over time it becomes self-motivated. They become deeply immersed in the activity, Also, due to the high concentration and strong self-motivation, learning takes place very quickly. The learner is eager to find the necessary sources and tools and spends time on the acquisition of skills, even if some aspects are not exciting in themselves, as long as they contribute to the autotelic activity.

    The reader would be well-advised to take the reports of hacking with a grain of salt. It is well known that the media will champion the opportunistic tendencies of hackers, while the feats which benefit humanity, such as the Internet and the Mozilla Firefox web browser, are ignored. These accomplishments, rather than than the compromising of computer systems, should be the ultimate definition of what a hacker is. But let the reader heed this wise advice: caveat emptor.

Error Catching!

Some time ago, I made an blog entry for automatically displaying man pages in Konqueror, but it seems that I forgot one of the most elementary — if not the most elementary — rudiments of programming: error trapping.

Because I would always take care to enter a command for which existed a man page, there was no need to loop until I entered a valid command; the program would just display an error message and exit. However, in making the previous entry I forgot that not everyone will do as I do, and maybe enter a command for which there is no man page. Re-invoking the command after each invalid entry was going to be a pain in the posterior; moreover, this condition is easily avoided with the judicious use of the while command.

Without further do, the amended kman script:


CMD_MAN=$(kdialog –caption “Kman” –inputbox “Enter command:”)

man -w $CMD_MAN > /dev/null

while [ $? -ne 0 ]; do

kdialog –caption “Man Page Error” –error “There is no manual page for that entry.”
CMD_MAN=$(kdialog –caption “Kman” –inputbox “Enter command:”)


/usr/bin/konqueror man://$(man -w $CMD_MAN) &

This should take care of the most common situation(s).

Happy Slacking!

Contributing back to the community!

Having built a comfortably powerful mini-ITX desktop recently expressly for the purpose of development, I found that most of the processor power was going to waste, because I was not developing quite yet. However, some time ago, I had heard of a project called Folding@Home, hosted by Stanford University, which uses the mostly-unused computing power of modern computers to help with fighting various diseases and conditions when proteins don’t fold just right. I’ll let the homepage explain more:

Proteins are biology’s workhorses- its “nanomachines.” Proteins help your body break down food into energy, regulate your moods, and fight disease. Before proteins can carry out these important functions, they assemble themselves, or “fold.” While protein folding is critical and fundamental to virtually all of biology much of the process remains a mystery.

When proteins do not fold correctly (misfolding), there can be serious health consequences, including many well known diseases, such as Alzheimer’s, Mad Cow (BSE), CJD, ALS, AIDS, Huntington’s, Parkinson’s disease, and many cancers.

If we better understand protein misfolding we can design drugs and therapies to combat these illnesses.

My thought was that if I could contribute to this worthy cause, then I could put this workhorse of mine to use while it is awaiting Real Work(TM).

My first step, therefore, was to download the client that I would need to start crunching the numbers. However, the download page only lists clients for popular Linux distros, such as Ubuntu, Fedora, and Debian. Being an enterprising Slacker, however, I remembered an entry in the Slackware Documentation Project which showed how to convert a Brother printer driver packaged in RPM format to a native Slackware package. I proceeded forthwith to the page, which showed the format the built-in package, rpm2txz, would need in order to do its magic:

rpm2txz -c -S -n -d <name of RPM package>

For two of the three packages which needed to be downloaded, FAHViewer (which gives a 3D visual of the number crunching), and FAHClient(which does the actual number crunching), this option works just fine. However, the third package, FAHControl (which controls the options), the process was not so cut and dried. Apparently, when this packages was created, Python 2.6.x and its ilk were the prevalent version(s).  Since Slackware has been at 2.7.x for some time now, the package (which was written in Python), would not run. This stumped me for awhile, as there was no easy solution (Read: Google gave me no direct answer). However, all the sites and forums which came up gave me the distinct impression that maybe moving the fah/ folder out of /usr/lib/python2.6/site-packages/ into /usr/lib64/python2.7/site-packages/  would do the trick. However, to make this happen, I had to make use of another of Slackware’s pkgtools collection, explodepkg. Not often used by yours truly, this requires that a folder is made and the converted package is copied into it. After issuing the appropriate command (no options needed) on the package, all of the subfolders appeared. (Note: after the explodepkg command is issued, the copy of the original package can be deleted). I then created lib64/python2.7/site-packages/ under usr/, and moved fah/ into it, like so:

mkdir -p lib64/python2.7/site-packages/

cd lib/python2.6/site-packages/

mv fah/ ../../lib64/python2.7/site-packages/

rm -Rv lib/

After going up one level to the main directory of the package, I typed the following to make the package:

makepkg -l y -c n /tmp/fahcontrol-7.4.4-noarch-1.txz 

After installing this package (not the one in the directory of the converted package!) in the /tmp directory, all three packages worked correctly. However, FAHClient will need to be started on boot, but that is easily accomplished. The fahclient package provides a startup script in the /etc/init.d/ directory (used in the other distros for startup), and you can link that script to one in the /etc/rc.d/ directory as rc.fahclient, as follows:

ln -s /etc/init.d/FAHClient /etc/rc.d/rc.fahclient

Check to make sure the executable bit is set, as the next step will depend on it:

ls -lha /etc/rc.d/rc.fahclient

If it is not set for some unfathomable reason, it can be accomplished as follows:

chmod +x /etc/rc.d/rc.fahclient

Next, in /etc/rc.d/rc.local, type the following to start FAHClient:

# Start fahclient
if [ -x /etc/rc.d/rc.fahclient ]; then
/etc/rc.d/rc.fahclient start

So next time you start your computer, the Folding@Home client will be started automatically, and you will be able to get a visual representation of the protein folding and adjust the options to your liking.

If you wish to exercise your l33t skills as an intermediate to advanced user of Slackware, you are more than welcome to try the preceding. However, for the beginning user (or for those who just don’t have the time and just want to get started immediately), I have made the packages available for download:




Note, however, that you will have to link the startup script in /etc/init.d/FAHClient to /etc/rc.d/rc.fahclient, and add the startup entry to /etc/rc.local.

I sincerely hope that donating unused computing cycles to a worthy cause will make you feel as good as it does me.

Happy Slacking!

Animated Wallpaper for KDE!

Some time ago, I came across this entry in, discussing the possibility of animated wallpaper for KDE 4.9.x. As I consider 4.9.5 to be the best version of KDE, I thought that I would check it out. I’m so glad I did. It adds nothing of value to the overall functionality of the KDE desktop, but it looks good. And I thought that I would exploit the power of the customizability of KDE to add some ability that is comparable to what’s available in the newest version of a certain popular OS. As there is no entry in SBo for this, I looked at the way that one builds a package, and considered that an older entry in SBo, smooth-tasks, used the same method. I thought that it would be trivial to modify the SlackBuild file to build the package. After much trial and error, I came upon a working package. In the spirit of Slackers everywhere, I will post the .tar.gz file here, and leave you to build the package yourself, since not everyone will be running 4.9.5 (On the latest version I ran, the package compiled and ran fine).

For details regarding this package, I refer you to the creator’s homepage. (I linked the homepage through Google Translate since Polish is not my native language).

Happy Slacking!


LILO’s new look, revisited

I recently received an email from a follower of this blog, and it looks like my words regarding the existence of the website I mentioned in a previous post proved prescient. Consequently, I am making a follow-up post regarding this issue. I have uploaded the image to my Copy account, and it may be accessed with the following link: Slackware_Moonboot.bmp

Please refer to my previous post about modifying your lilo.conf file to accommodate the color .bmp file.

Happy Slacking!

The One True Keyboard!

Sorry if this sounds somewhat like a tech-religious title, but I just got to thinking about how to type better, since I use the F1-F12 keys quite a bit, and just got fed up with using the ‘F-Lock’ key to enable them. (I currently own a Microsoft Office Keyboard). I began thinking that since I was going to change keyboards anyway, why not go all the way and get a mechanical keyboard? As you may or may not know, the majority of keyboards made today are of the rubber dome variety, and force your hands to work harder, since you have to bottom out the key before a letter (or character) appears on the screen. The particular keyboard I’m thinking of is comprised of individual switches for each key, complete with springs that buckle when pressed. At the instant the spring buckles, a character is produced on the screen. Since this method is so reliable, one can use one’s ears for audible feedback on when a character has been entered, and thus does not have to look at the screen to verify. There have been reports that typists can hit high speeds when using this keyboard. Which keyboard am I rambling on about, anyway? I wrote a review of it on, and I’ll summarize the relevant parts of it here:

I remember the classic “Model M” buckling spring keyboard, when I was in high school back in the mid-to-late 80′s. I was taking some business class (can’t remember the name of the class, been too many years ago). The machine was a PS/2, and the keyboard was, of course, a Model M. At the time, I didn’t give much thought to the sound the Model M makes as one types on it; I just thought that was the way the keyboard was supposed to sound. How little did I know how right I was (although I can definitely empathize with the people who complain about the noise; this keyboard is definitely not silent, although that’s the trade-off you made for choosing a great keyboard).

Since proficiency in coding and writing essays has become somewhat of a “holy grail” for me, I have since revisited the topic of keyboards. Some time ago, I started researching what makes a keyboard great, and have come away with the impression that IBM did it right almost 30 years ago — great tactile feedback via buckling springs, extremely durable construction, completely standardized layout, and operating system agnostic.

I use Linux (Slackware to be specific), and after great deliberation, have come to the conclusion that the Model M (and its successors) follow the UNIX philosophy: Do one thing, and do it well. The keyboard is, above all, meant to be a text entry device, whether you are using it to compose essays, write web pages, or for programming. No more, no less.


If you want a quick bit of history on the Model M, you can read it here.

Since IBM (and Lexmark) are no longer manufacturing keyboards, Unicomp (a subcontractor to Lexmark) purchased the rights to the Model M, and are manufacturing modern replicas of them. I took the liberty of ordering one. Warning: If you want a well-made keyboard, expect to pay more than the piddly $20 or so you would at Wal-Mart or similar retailers. This one cost 4x that, and I consider it a bargain.

Here’s a picture of the black beauty, in case any of you are interested:


For comparison’s sake, here’s a picture of the original IBM Model M:


Visually, they are quite similar, except for the brand name, color, connector (USB instead of PS/2), and other minor details.

Now, why did I not get a keyboard with the Windows key on them, you may ask? Because I despise the Windows key. I have never, in all my years of owning keyboards, make use of the Windows key. I despise Microsoft for taking the clean layout of the Model M, and messing it up.  That is purely a subjective opinion; you make take it as you will.

I can’t wait to get mine in the mail, sometime this week!

Make KDE’s Konqueror display man pages automatically

If you’re anything like me, if you’ve been around Linux for awhile, you find yourself referencing man pages quite a bit to learn how something works. The traditional way to display man pages is through a terminal session. The problem (for me, at least) is that navigating the whole of the man page is irritating, to say the least. You have to use the keyboard to go up and down the man page, and that gets old real quick when the man page is long, and the information you need is at opposite ends of the page (which tends to be the case more often than not, if Murphy has his way). Well, there’s a solution. The KDE developers, in their infinite wisdom, endowed their own web browser, Konqueror, with the ability to display man pages. There’s only one problem. There is no easy way to go directly to the man page of the command you want (at least none that I was able to discover). So, in the traditional Unix way, I set about looking for a solution using existing facilities. It did not take me long to find it. The ‘man’ command has an option switch which gives the location of the man page of the command that one wants, which Konqueror needs to display the page.

I opened a pico session, using pico /usr/local/bin/kman, and typed in the following:


if [ -z "$1" ]; then

        echo “You did not enter a user command.”
        echo “Please enter a user command.”
        exit 1

if man -w $1; then

        /usr/bin/konqueror man://$(man -w $1) &
        echo “There is no man page for your entry. Please enter a valid command.”
        exit 1

For those of you unfamiliar with shell scripting, here’s a quick rundown: the -z option of the if statement tests for a null value; in this case, that would be $1, or the first character(s) after the command, which, in this case, would be the man page of the user command which we are interested in. The reason for this is to test for a null entry; that is, if one just entered the kman command and pressed <Enter>.

The second test may be a bit more obscure, and needs a little explanation. (I had to look this up myself). It tests to see if the man command was successful, which it will not be if one enters a command for which there is no corresponding man page, or just enters pure gibberish. If it is successful, the next line of code will be executed.

The -w option of the man command gives us the location of the man page in question; $(man -w $1) passes the location of the man page to the command line, right after the man:// portion. The ampersand (&) tells the shell to run the command in the background; otherwise, you would not be able to use your terminal session until after you closed Konqueror.

So there you have it, Slackware citizens; a quick and easy way to use Konqueror to display man pages on the fly, using built-in facilities. It really doesn’t get any better than that.

Happy Slacking!

P.S. I edited the kman script to add a test for an invalid entry, as well as for a null entry.

P.P.S – I found this great program that’s a part of KDE; kdialog is a program used for shell scripts that want to use a GUI as input, and output an error, also in a GUI. I used it, and found it to be much more useful; all I have to do is to launch it in the quicklaunch toolbar (after I set up the launcher manually, naturally), and up comes a dialog box asking for what I want, which is the command’s man page in this case, and if it’s not found, I use the error option of kdialog to tell the user so. Just what the doctor ordered!

For those who find the concept of using a GUI to interact with kman more appealing, here’s my new revised script:


CMD_MAN=$(kdialog –caption “Kman” –inputbox “Please enter the command for which you want a man page:”)

if man -w “$CMD_MAN”; then

        /usr/bin/konqueror man://$(man -w $CMD_MAN) &
        kdialog –caption “Man Page Error” –error “There is no man page for your entry. Please enter a valid command.”

Makes the program a bit simpler to read and understand, in my humble opinion.


Get every new post delivered to your Inbox.