OneTruePath

This is a rough transcription taken from wiki:OneTruePath...

...For those who wish to be a Master (see below the horizontal line for alternative paths):

Find a graveyard 386 or 586 computer. You can get such a machine for free (or nearly free) at a computer-repair shop or recycling yard. 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. Also, ensure that it has a two-state power button (true on/off) and a reset button in case you lose software-level control (using 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, 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, the easier it is for both your hardware and OS. Find the model of your motherboard, CPU, video card, harddrive(s), bus interfaces, RAM type, IRQ pin settings (if any) for all the hardware, and write it all down. 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 its 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 Linux [without] on your machine. Keep a partition of 100MB for DOS/Windows and one for SWAP that is twice the size of your RAM (10x if your making a multi-user machine). Command line is going to be your best friend, so consider this before indulging too much in questions about what window manager (Enlightenment, GNOME, KDE, blah blah ) you're going to use. The only thing that matters is X. Customize your GRUB or LILO software configuration for dual-boot and install DOS v3.3 or v5.0 if you can (on your non-linux partition). Windows if you want.

Do all your system administration from the command line. This will make you proficient on any machine regardless of applications 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 and figure out at which point does the core or "kernel" of your operating system actually start. Yeah, 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.

When you see the difference between the kernel and the rest of the operating system running in UserSpace, customize your kernel ($make menuconfig) 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.

Now you are worthy of programming the computer. First learn C (gcc on linux). C translates into computer code quite cleanly. You don't have to suffer through assembly anymore. Your Operating System is written in it. Make a program to list the first 100k prime numbers, then make one without the 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.

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.

Tasks to consider:

• Create a mini operating system of your own that's capable of performing several tasks without blocking the user's keyboard and screen I/O. 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 sqrt(MAXSIZE)) in assembly.

Now: move to a high-level language so you can be rapidly productive. Save shell scripting for file-system traversals and system administration. Choose Python or Ruby for higher-level tasks; no one really knows what to do with the power of the computer when coupled with the power of the network. Like cavemen, they've seen everything as a "nail" and the computer as the "hammer": number crunching and business accounting. But we'll be using the elegance of the machine for something more. Eventually, you're going to use a high-level InterpretedLanguage because you need to experiment with ideas -- any optimization at this point is premature. Besides, you've followed the path to this point and know not to casually waste resources, right?

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 insanely fast.

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.

Towards building the PerfectSystem,

TheMasterOfTheMachine

[1] See http://www.retrothing.com/2006/12/the_tinkertoy_c.html, http://www.rci.rutgers.edu/~cfs/472_html/Intro/TinkertoyComputer/TinkerToy.html

---

An alternative (or addendum) to the above method(s), is this:

• Get a job as a computer technician, repairing and building computers -- not at some big box store like "Best Buy", but a small business. 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.
• Build your toolkit. You want a small toolkit that you can carry around 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)
• 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.

In any case, after you assemble your great pieces of hardware and have gotten linux optimized well (compiled and tuned it to your machine), here's what next:

• You must realize the nature of data; that it relates to something from RealLife, put into the machine -- it's not just random.
• Then, you must realize that AllDataRelatesToOtherData since the world is interconnected. Your windowing system is a crude way to interact with that data, so you have a file system as a neutral mediator between applications.
• Next, you must see the right environment for such a Data Universe: a ThreeDimensionalVisualizationModel. But then, you ask "how?"

Task to consider: Enroll at a University in Computer Science or Engineering. Understand the simplicity of a Turing Machine and, then, how that abstraction relates to the underlying (concrete) hardware.

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