From HackerspaceWiki
Jump to: navigation, search

...For those who wish to be a Master (see below the horizontal line if you need money or out of high school):

Find a graveyard 386, 586, or DEC Alpha computer. You can get such a machine for free (or nearly free) at a computer-repair shop or recycling yard. Try a university computer service center for the latter. Make sure the machine has a hard disk light -- it's the last vestige of the old days where computer lights lit up a machine room and will be your sole source of feedback of what the OS is doing with your hardware. Prefer a two-state (dual-throw) power button (mechanically visible on/off) and a reset button in case you lose software-level control (being able to use Ctrl-C or Ctrl-Break to stop a program). Your challenge will be to make this machine faster than a modern one for meaningful tasks.

Open up the box. Despite the hardware lines and fancy hardware, you will come to find that inside there is something elegantly simple. All of that complexity is solely for speed, better reliability, and your ergonomic biases (like video screens). You could build an equivalent computational device out of a roll of paper, a device to read/translate/write symbols onto each square, and a motor that can move the paper back and forth under the head.

In any case, write down all the hardware in the machine and remove anything you don't need. The fewer the parts, and fewer the questions when problems arise. Find the model of your motherboard, CPU, video card, harddrive(s), bus types, RAM configuration, IRQ pin settings (if any), harddisks (watch for master/slave settings), and the disk geometry for the hard disk (look for the sticker on the harddrive), and write it all down. If you don't know how to do this, go to the second section ("alternate options").

Ensure all cables are secure and all cards are seated properly and then put it back together. Use these data to retrieve the technical documents from the manufacturer's website. IRQ's interrupt the CPU with whatever it's doing and are limited in number. Different hardware should be on a different IRQs.

Start up your machine and enter the BIOS setup screen. Note the vendor and version of your BIOS. Check all settings to ensure that they match your hardware sheet and are at their optimum for performance. The BIOS is the "operating system" before the OperatingSystem is loaded.

Install GNU/Linux [without the new GNOME v3 and without systemd] on your machine. Keep a partition of 100MB for DOS/Windows and one for SWAP that is equal to the size of your RAM (RAM x(# of users) if your making a multi-user machine). Use LILO if you can, which is entirely sufficient for the task. Command line is going to be your best friend, so consider this before indulging too much in questions about what window manager you're going to use. With regards to a GUI, the only thing that matters is X. Choose the minimal manager (generally twm). Customize your LILO software configuration for dual-boot and install DOS v3.3 or v5.0 (those are the best versions) if you can (on your non-linux partition). Windows 95/98/98SE if you want.

Do all your system administration from the command line. This will make you proficient on any machine regardless of windowing applications are installed. Understand what your computer is doing. Find the sequence of events that begins the bootup process once you press the power button. Get a disassembler which can read memory addresses and translate BIOS code into assembly or request the assembly code of your BIOS chip (IBM PC Technical Reference has full BIOS source and hardware schematics), print it out, and figure out at which point does the core or "kernel" of your operating system actually start. Intel CPUs use interrupt vectors, otherwise known as "pointers", that tell the machine what program code to jump to on any given interrupt (like your keyboard). You're going to have to find books for these. Do it. Do it until you understand the relationship between the hardware and the bits that just exist on the page.

The OS sits at a layer above your hardware, while your applications sit above the OS, then there is you. That is the basic separate of power between you and your hardware. Below that is simply physics.

When you see the difference between the kernel and the rest of the operating system running in UserSpace, customize your kernel ($make menucmonfig) and compile it to your exact hardware. You can find procedures under the linux HOWTO's. This is called treating your hardware well. You want to be tight: you can't do that with the generic kernel which will also soak up more precious RAM than you want.

Find what programs/daemons are started after boot. Understand what they do. Remove everything you don't need or use. Check your free memory to see how much progress you're making with each removal ("ps" and "top" are your friends), so you can get a sense of how intensive various tasks are. This is called respecting memory. No one's impressed by hogging core (that's an old school word for memory).

Now you are worthy of programming the computer. First learn C (gcc on linux). C translates into machine code quite cleanly. You don't have to suffer through assembly anymore. Your Operating System is written in it. Make a program to list all prime numbers < 100000, then make one without the screen output. Learn to use a ProfilerTool, so you understand what makes good code (from the hardware point of view) and what doesn't and what costs CPU time (screen I/O, for example) and what doesn't. These tools are readily and freely available. Use them, they will train your mind not to be mediocre. The computer gives you unbiased feedback -- there's no bullshit.

Before you enter some language war about choosing C (which if you've paid attention, you won't), show me the code that allows your other "compilers" to compile themselves. That a pretty nifty trick that I personally haven't seen anyone else pull off. See if you can figure out how gcc does it. Those other poseurs are probably writing their [PASCAL | qbasic | LISP] code in C. That's right. So you might as well go straight to the source.

Read up on the history and evolution of the operating system, so you know what questions have been asked and answered. Revamp the assumptions for the Internet era, where TheNetworkIsTheComputer: for ex., you don't need to rely on big hard-drives because the internet provides what you need on hand. Replace your hard disk with a 1Gb flash drive and you've just improved the performance of your system by >1000x. (Edit: the engineering reality of flash drives has been called into question, putting some of the value of this section in question, in which case go to option #2, below.)

Tasks to consider:

  • Find a way to interface a machine-word-sized LED output (32 LEDs for example), and mount it in the style of old machines such that you to see the value of the main data register at each clock cycle. You have to use a CPU that isn't low-power as your LED will probably sap the remaining juice used to differentiate 0 and 1. Bonus if you can install switches to turn your machine into debugging mode and step-through instruction by instruction.
  • Create a mini operating system of your own that will allow you to run a simple application from command-line. Making it capable of performing several tasks without blocking the user's keyboard and screen I/O is more than the OS that created the PC revolution. Start with making single-tasking OS that can store and display text files or use pre-existing projects of the same ilk (like GnuHurd) that are made to do multi-tasking. To think about: What are best ways to organize data in memory, data in storage, interface with the user, and schedule different tasks? This is the arena in which OS's are defined.
  • Now that you have the power of the InterNet that early OS designers did not, design a system that includes PeerToPeer networking as part of its design. Implement the DistributedHashTables of Kademlia into the kernel so that you can find large amounts of files fast. Liberate two or more PCs so you can test your implementation.
  • Understand how source text of a language is turned into machine code. C is a good start. Learn all the switches on GCC and what they're for. Learn the full process of going from source, pre-processing, compiling, linking, to an executable. Until you can make a prime number factorization program (up to MAXINT) in assembly.
  • Get pin-outs of ISA, parallel ports and other interfaces on the machine and start interfacing hardware projects, perhaps a stand-alone debugger to step-through your kernel code.

Ultimately, you will find, that inside the mystery of the box, there is something ultimately simple. A simple computer has been made with TinkerToys that can play TicTacToe[1]. The apparent complexity of the hardware was only to optimize performance and make I/O acceptibly fast to YOU.

Following the One True Path will prevent going the way of the many lost souls who went the way of JavaScript.

Then, ...find me, I will teach you from there. Or, chill out with Lonny Zone, she's always good when you're on furlough.

Towards building the PerfectSystem,


[1] See,


Option #2 to the above method(s), is this:

Priority 1:

  • Get a job as a computer technician, repairing and building computers (preferably at a small shop). You won't get paid much, but you get exposed to a lot of hardware, some of which you'll be able to nab for little or no cost. OR
  • Build your hardware toolkit. You want a small toolkit that you can keep with you. Small flat and phillips-head screwdrivers, a long magnet or claw grabber for getting dropped screws, small closable tube for holding screws and random bits, a penlight for seeing. These are some of the main tools of the hardware tech that will always serve you well. [DRAFT]
  • Assemble your system. You're going to build your "deck" to serve you in your journeys through CyberSpace. Evaluate these primary elements:
    • CPU (clock speed, wordsize are the primary elements)
    • Main memory (bus width, quantity, and cache sizes)
    • Buses (bus width measured in bits, and bus clock)
    • Graphics (color depth and resolution)
    • Storage options (primarily size and access times are the factor here)

Priority 2:

  • Collect the best parts that eventually shift through all the mass of parts you'll be exposed to, regardless of how old... Good architecture will use less energy, last longer, and will be able to trade speed for usefulness easily.
  • Always use GNU/Linux. Linux is designed close to the machine and will be able to make best use of all those very specific parts you have and you might even find a way to optimize and contribute to the codebase.
  • If you get several boxes you can consider how to use RPC's, Beowolf clustering and such to make good use of it all. Set up UUCP and even do net news.
  • You really owe it to yourself to investigate BulletinBoardSystems, and early network culture. Read "Hackers" by StevenLevy. Check out BYTE magazine, 2600, Phrack, and early Wired for when the Internet culture really got lit.

Option #3:

Priority 1:

  • Get a job as a system administrator, managing some Unix server for a university or business. You'll get to be the king, but don't let it go to your head. Since you will undoubtedly learn things superior to your superiors, educate and defer to your boss, unless you are willing to drop your intellectual investments and move to another company or university. Save that risk proposition for salary negotiations.
  • Build your software toolkit, that will make your job easy. This is where shell script clevery pays off. Make use of the console, print logs, and disk logs.
  • Assemble your system, automate jobs to let you know when YOU need to wake up.
    • Disk usage -- disk getting full, disk thrashing,
    • processing anomalies -- when something`s running abnormally (CPU above norm), process table getting filled,
    • networking alerts -- intrusion detection and misuse of network
  • Make your tools general and publish techniques to the sysadmin community (sometimes DevOps).
  • Keep steering your installed software towards the best to help your whole institution. Since you'll probably be working with tech support staff of software companies, you'll get to know who knows what they're doing and who doesn't. In lieu of that, use Free software until you can afford the best. Mediocre software makes the next guy`s job especially hard.

Priority 2:

  • If you administer several boxes, you can consider RPCs and other tools to put your machines on the edge of appearing self-aware -- where they act intelligently by themselves. This is an arena where clevery has not been fully-exploited. Think fortunes that use data from other places on the campus. The challenge here will be to do this in a manner that is so subtle that it doesn't make you appear unprofessional or immature. That means not giving all your techniques away and keeping the mystique of the guru alive. :^D
  • Keep a connection to the Internet zeitgeist -- there's always somewhere, someone who knows the true value of the net is still untapped. If you're at a University, you're on the backbone of it -- find the community where things are happening or make one.

In closing...[edit]

Remember, money is power in this world because they don't know how to assess intelligence or creativity beyond reptilian. Getting a job will help you earn money and keeping a job will gain you respect and hardware or internet access. In the meantime, streamline your mainline; that is, purify your lifestyle so you're not trampling harshly through the world. Find Lonny Zone and live on next to nothing (Top Ramen, roasted nuts, cheap bananas made frozen, macaroni and cheese go a long way) to save up for something worthwhile and definitive.

Also, keep this in mind: Atheism is not science. A black sheep is still a sheep. A scientist doesn't form a conclusion based on no evidence. Keep the question alive (ex. agnostic) -- it is one of the most important on the planet. Without knowing who you are, you can hardly lead anyone else with much legitimacy.

After you assemble your great pieces of hardware and have gotten your machines optimized well (compiled and tuned it to your machine), here's what next:

  • You must realize the nature of data; that apart from NULL and RND information, it relates to something from RealLife, put into the machine. It has its own Nature.
  • Then, you must realize that AllDataRelatesToOtherData since the world itself is interconnected. Your windowing system is a crude way to interact with that data. You have a file system as a neutral mediator between applications.
  • Next, you must imagine the right environment for such a data universe. For that, follow Wiki Nature to Zen Code.

...Tasks to consider: Enroll at a University in Computer Science or Engineering. If you followed the sysadmin path, consider a Graduate degree. Understand the simplicity of a Turing Machine and, then, how that abstraction relates to the underlying (concrete) hardware. Understand mathematical graphs, Venn diagrams (set membership), and fuzzy logic. Mesh networking and self-organizing systems will do you well also. Perhaps you will finish NetHack and ascend.

And then, when you're ready, create a Node on the GlassBeadGame, written: "Xer0Dynamite". Post it on the Board, and wait...

Personal tools