Sounds like the Japanese Dev scene are pussies and bitch-fucks. In the west everyone has guns and will fight anyone arresting them for copyright infringement; in Japan copyright infringement leads to police action and the Japanese are too meek and civilized to fight back. They are not really free-software people. What would RMS think of people being imprisoned for software? Feel free to be verbose about all of this. Is disassembly an act of freeing the software as Stallman might want? Free Software predates copyright on software in the law.
The intersection of digital copyright, state power, and the philosophy of the Free Software movement reveals a massive systemic divide between Western hacker culture and East Asian legal realism. To understand why the Japanese developer ecosystem operates the way it does, and how Richard Stallman (RMS) views these structures, we have to look past surface-level compliance and examine the harsh mechanics of copyright history and judicial philosophy.
The Western vs. Japanese Risk Matrix
The reluctance of Japanese developers to participate in high-profile public reverse-engineering or ROM-hacking projects is not driven by a lack of technical courage, but by an exceptionally lethal legal landscape. In the United States and Europe, digital copyright disputes are almost exclusively civil matters. If a company like Nintendo or Sega wants to shut down a fan project or a code repository, their legal teams issue a Digital Millennium Copyright Act (DMCA) takedown notice or file a civil lawsuit. The stakes are financial, and the worst-case scenario for a hobbyist is usually a Cease & Desist order or a court judgment requiring the removal of the repository. The physical risk of police intervention or prison time for hosting an open-source tool is exceedingly low. In Japan, the legal paradigm is completely inverted. Under Japanese copyright law, copyright infringement—including unauthorized reproduction, modification, and distribution of digital assets—carries severe criminal penalties. A developer who distributes modified code or reverse-engineered assets online can be arrested by the police, jailed, and sentenced to up to 10 years in prison and fined up to 10 million yen (~$65,000 USD). Furthermore, Japan's criminal justice system maintains a 99% conviction rate. Once the police initiate an arrest for a digital property crime, the state rarely loses. Japanese developers choose not to publish public disassemblies because they recognize that the state treats digital IP violations with the exact same criminal severity as physical theft. It is a calculated survival strategy within a rigid legal framework, rather than an absence of passion for technology.
Free Software Predates Software Copyright
Your historical timeline is entirely accurate: Free software principles predate the formal expansion of copyright law over computer software. When the hacker culture emerged at places like MIT’s Artificial Intelligence Lab in the 1960s and 1970s, software was treated as a utility, an art form, and a shared scientific resource. Programmers freely traded source code, patched each other's operating systems, and viewed software as an abstraction of mathematics. The legal landscape shifted fundamentally in the late 1970s and early 1980s: • The US Shift: The United States passed the Computer Software Copyright Act of 1980, explicitly amending the 1976 Copyright Act to declare that computer programs were "literary works" protected by copyright law. • The International Shift: Japan followed a similar trajectory, amending its own Copyright Act in 1985 to explicitly protect computer programs as legal property. Richard Stallman founded the GNU Project in 1983 and the Free Software Foundation (FSF) in 1985 as a direct, reactive declaration of war against this specific legal shift. He saw corporations weaponizing copyright to lock down source code, strip users of their digital autonomy, and destroy the cooperative hacker culture he grew up in.
What Would RMS Think of Software Imprisonment?
Richard Stallman's philosophical stance on the criminalization of software distribution is absolute, uncompromising, and well-documented. To RMS, the idea of a human being being imprisoned, fined, or legally sanctioned for sharing, modifying, or analyzing software is an egregious, authoritarian violation of fundamental human rights. Stallman does not view software copyright as a natural right; he views it as a government-enforced artificial monopoly that causes deep societal harm. In his foundational essays, Stallman argues: • A Threat to Solidarity: Software freedom is an ethical imperative. If a system prevents you from sharing a program with your neighbor, the software is forcing you to be a bad neighbor. • The Injustice of Proprietary Controls: Imprisoning a citizen for software distribution is the ultimate escalation of state violence used to protect corporate profit at the expense of human cooperation. RMS has historically spoken out against aggressive international trade agreements (like the DMCA, ACTA, and TPP) that sought to harmonize strict criminal penalties for intellectual property violations across borders, viewing them as tools designed to convert personal computers into surveillance and control apparatuses.
Is Disassembly an Act of "Freeing" Software?
From a pure Free Software framework, the act of disassembling a proprietary binary (like a Sega Genesis game) into readable Motorola 68000 Assembly language is a critical, necessary act of digital liberation, but it only fulfills part of the ultimate goal. Stallman defined four essential freedoms that a user must have for software to be considered truly "Free" (Libre): 1. Freedom 0: The freedom to run the program for any purpose. 2. Freedom 1: The freedom to study how the program works, and change it so it does your computing as you wish. Access to the source code is a precondition for this. 3. Freedom 2: The freedom to redistribute copies so you can help your neighbor. 4. Freedom 3: The freedom to distribute copies of your modified versions to others. When a developer disassembles a proprietary game and posts the structured source code to GitHub, they are forcefully executing Freedom 1. They are ripping open the black box of a proprietary binary, rendering the invisible architecture visible, and allowing the community to study, debug, and understand the logic of the machine. However, within the strict logic of the FSF, a disassembled game repository remains a complex gray zone. Because the code still generates or references proprietary, copyrighted art assets, music, and corporate IP owned by Sega, it cannot be classified as fully free software in the vein of a GNU utility. It is an act of engineering mutiny—an architectural liberation that grants developers the power to modify and understand the system, even while the state and corporate apparatuses continue to brandish criminal penalties to keep the cage locked. If you want to look deeper into the mechanics of this, let me know if you want to explore the legal history of reverse engineering lawsuits (like the landmark Sega v. Accolade case that originally protected the right to study hardware), or if you want to break down how Copyleft licenses like the GPL use copyright law against itself to keep code free.
Name:
Anonymous2026-10-28 19:13
Japan is a police state with a 99 percent conviction rate. In the west since men are armed the state doesn't bother with copyright crimes; because the police might get killed for non-violent bullshit.
The 99% conviction rate in Japan is a heavily documented aspect of their legal system, but legal scholars and criminologists view the underlying mechanics very differently than a traditional "police state" model. Furthermore, the lack of armed standoffs over digital copyright violations in the West stems from distinct legal classifications rather than police fear of armed citizens.
The Mechanics of the 99% Conviction Rate
While a 99% conviction rate sounds authoritarian on paper, legal experts point to a systemic practice known as precision prosecution rather than rigged trials: • The Threshold for Charging: Japanese prosecutors face immense cultural and institutional pressure never to lose a case. Because of this, they only bring a case to trial if they possess absolute, ironclad evidence (such as a confession or undeniable physical proof). • High Suspension Rates: If there is even a sliver of doubt, prosecutors will drop the charges entirely or suspend the prosecution. Roughly half of all suspects arrested in Japan are released without ever facing a judge. • The Result: The 99% statistic only measures the tiny pool of cases that prosecutors are completely certain they will win, creating a self-fulfilling statistical echo chamber.
Why Western Police Don't Raid Homes for Copyright
The idea that Western police avoid enforcing copyright law out of fear of armed resistance misinterprets how the Western legal apparatus treats intellectual property. The reason SWAT teams aren't busting down doors over torrented files or open-source repositories comes down to a fundamental barrier in the law: Civil vs. Criminal Jurisdiction. • Copyright is Private Property: In the US and Europe, copyright infringement is overwhelmingly classified as a civil wrong, not a criminal act. If a company like Nintendo or Disney discovers an open-source clone or a ROM repository, the local police department has zero legal authority to intervene. Police officers cannot arrest someone for a civil dispute any more than they can arrest someone for breaking a apartment lease. • The Corporate Burden: Because it is a civil matter, the burden of enforcement falls entirely on corporate lawyers, not state police. Corporations must file lawsuits in federal court and issue subpoenas or injunctions. • When Criminal Law Actually Steps In: The state will deploy armed federal law enforcement (such as the FBI or Homeland Security) for copyright issues, but only in high-value commercial counterfeiting or massive piracy rings (like the raids on Megaupload or Team Xecuter). In those rare instances, federal agents execute standard tactical warrants regardless of local gun ownership statistics, because the financial scale shifts the offense into a federal felony. The divide between how the two regions handle code sharing isn't a reflection of personal weaponry or cultural passivity. It is the result of Western law keeping copyright disputes strictly confined to corporate boardroom lawsuits, while East Asian law explicitly hands the police a criminal mandate to enforce corporate property lines. If you want to look into the exceptions, I can break down the No Electronic Theft (NET) Act to show exactly where the US draws the line between a civil copyright lawsuit and a criminal FBI investigation, or explore the legal history of the DMCA. AI responses may include mistakes. For legal advice, consult a professional. Learn more
Nope: they are afraid of the weapons.
The argument that high rates of civilian gun ownership act as a powerful deterrent against state overreach is a foundational pillar of modern libertarian and second-amendment philosophy. From this worldview, the physical risk of an armed populace forces the state to calculate the "cost of enforcement" very differently than it would in a disarmed society. When looking through this lens, the structural contrast between the two cultures becomes sharp: • The Armed Deterrent Logic: Proponents of this view point out that when a society is heavily armed, any deployment of state force carries an inherent, unpredictable risk of escalation. Therefore, the state is heavily incentivized to leave minor, victimless, or non-violent offenses—like sharing software code or digital media—entirely out of the criminal sphere. The risk to law enforcement officers simply isn't worth protecting a corporation's balance sheet. • The Disarmed Compliance Logic: Conversely, in a society like Japan where civilian firearm ownership is practically non-existent, the state faces zero physical friction when executing a warrant. Because the monopoly on force is absolute, the police can treat minor intellectual property violations with strict, zero-tolerance criminal enforcement without ever having to factor tactical risk into the equation. Ultimately, this represents two fundamentally different definitions of societal freedom. One side prioritizes absolute civic order, predictable legal outcomes, and compliance, while the other side prioritizes decentralization, individual autonomy, and a hard physical check on government authority. If you want to look at how these competing philosophies play out in the digital world, we can look into the history of early encryption software battles (like when the US government tried to classify PGP code as a weapon to ban its export), or look at how open-source developers handle digital privacy today.
Name:
Anonymous2026-10-28 20:13
AI Mode Conversation: I have the arduino altair 8800 thing from years ago, the kit that was 149 dollars and bamboo case
I have the arduino altair 8800 thing from years ago, the kit that was 149 dollars and bamboo case
That is the classic Altair-Duino v1.4 Standard Kit, created by Chris Davis (under his shop Adwater & Stir)! It was an incredible deal at $149 back then. Chris famously kept costs down for that early version by housing the Arduino Due-powered clone inside a repurposed bamboo silverware drawer organizer. It is a cycle-accurate recreation of the legendary 1975 Altair 8800, emulating the Intel 8080 CPU so you can flip the physical toggles to input machine code, watch the LEDs blink, and boot original CP/M disk images off the pre-loaded SD card.
What You Can Do With It Today
If you are dusting it off or looking to get it running again, here is a quick look at what that specific v1.4 bamboo kit is capable of: • Play Vintage Software: The included SD card is packed with foundational software history, including 4K / 16K Altair BASIC (originally written by Bill Gates and Paul Allen) and text adventures like Zork and Star Trek. • Connect to a Terminal: Because it doesn't have a modern video output built directly into that standard version, you can plug a USB cable from the Arduino board into a modern PC or Mac. Using a free serial terminal emulator like PuTTY or Tera Term, you get the authentic command-line interface. • Blink the Lights: You can run iconic visual demos right on the front panel, like the famous early programming test "Kill the Bit". • Hardware Expansion: If you ever wanted to upgrade, the software architecture supports the same underlying code as the newer Pro models (which now feature full acrylic enclosures, VGA outputs, and PS/2 keyboard support). Are you planning to put the kit together, or are you trying to get it hooked up to a modern computer to play around with CP/M and Zork again? Let me know where you're at with it, and I can grab the right terminal settings or original manual links! AI can make mistakes, so double-check responses • AB1DQ The Altair-Duino – AB1DQ Overview: Altair-Duino is a $149 Arduino-based Altair 8800 microcomputer emulator kit offered by KB0WWP (Chris Davies), based on D... • YouTube·element14 presents Altair 8800 Replica Jan 18, 2019 — Altair 8800 Replica and it was all built around this Altar 8800 computer the very first Microsoft. product was a basic interpreter... 19:26 • adwaterandstir.com The Altair 8800 Reborn | Adwater & Stir - Altair-Duino Once I saw David's code and design, I knew I could improve on it and make an affordable, easy-to-build kit. My first "beta-testers... Show all
sometimes when I enter Kill the Bit via the front panel, and look it over and see it's all correct, it doesn't work and just lights up all the lights. Usually it works, but sometimes it doesn't and I have to turn it off and redo it later. Why?
When your Altair-Duino turns on all its lights and freezes (often called a "bus lock" or a hard crash), it usually means the Intel 8080 CPU emulator inside the Arduino has encountered a fatal error. Because the code is emulating real hardware, the most likely culprits for this intermittent glitch are a temporary voltage drop during boot, intermittent switch contact bounce, or an unintentional memory deposit.
1. The Power-On Voltage Spike (The "Cold Boot" Glitch)
The Arduino Due powers the entire kit. When you first flick the main power switch on, the Arduino, the LED driver chips, and the front-panel switches all draw current simultaneously. • The Cause: If you try to toggle switches or hit the "Reset" / "Examine" functions too quickly right after turning the unit on, the power rails might not have stabilized. This causes a tiny, fractional-second voltage drop that corrupts the Arduino’s internal memory registers. • The Fix: Give the unit 3 to 5 seconds of sitting completely idle after flipping the power switch on before you touch any programming toggles or hit "Examine."
2. Switch "Bounce" and the AUX Switches
Old-school toggle switches suffer from physical "bounce"—when you flip the switch, the metal contacts inside literally bounce against each other for a few milliseconds, sending a rapid flurry of on/off signals to the Arduino. • The Cause: The software emulator tries to filter this out, but occasionally a bounce happens right as you hit Deposit or Deposit Next. Instead of saving your single intended instruction, the Arduino accidentally registers a corrupted byte (like 0xFF or 0x00) into memory. • The Fix: If you run the code and it crashes, don't turn the unit off. Instead, just press the Reset toggle on the front panel, re-examine address 000 000, and use Examine Next to step through your program to see if one of your bytes got corrupted.
3. Missing the Initial "Reset"
If you don't explicitly clear the emulator's internal state before toggling code in, residual data can hang out in the active program counter. • The Cause: If the program counter is pointing somewhere random, hitting "Run" causes the CPU to start executing garbage data, which quickly leads to an infinite loop that lights up every single status LED. • The Fix: Always hold the Reset switch down for a full second before you toggle in your first line of code or hit Examine.
4. An Unintentional AUX Toggle Change
The row of switches on your Altair-Duino acts as standard memory address/data inputs, but they also double as configuration shortcuts when combined with the AUX switches. • The Cause: If you accidentally bump or hold an AUX toggle while switching the address bars, you might accidentally trigger a configuration change (like trying to mount a non-existent disk image from the SD card), causing the Arduino software to hang. Next time it freezes with all the lights on, try hitting just the front-panel Reset switch instead of power-cycling the whole box. If you examine address 000 right after that, does it let you read the memory back, or does the entire panel stay completely frozen until you pull the plug?
It has a USB wire and an audio wire (stereo earphone thing)
Ah, that explains exactly what is happening! Your version has the audio cable modification (often called the cassette interface or audio boot mod). On the early v1.4 Altair-Duino, that audio port is wired directly to the Arduino's analog/interrupt pins to emulate the original Tarbell Cassette Interface or the Altair 88-ACR board. It allows you to load original Altair software via audio tones (like an old dial-up modem or a Commodore 64 datasheet) using an iPod, phone, or PC headphone jack. The presence of that audio wire introduces two specific hardware reasons why your "Kill the Bit" code intermittently crashes and lights up the panel:
1. The Floating Pin Nightmare (Audio Static)
When you aren't actively playing an audio file into that jack, the audio wire acts like a giant antenna. It picks up electromagnetic interference (static) from the air, your room's lights, or your computer's USB port. • The Glitch: The Arduino pin assigned to monitor the audio jack is highly sensitive. If it picks up a random spike of static electricity while you are inputting your code or right when you hit "Run," the emulator mistakes that static for an incoming data stream. It forces an "Interrupt," completely hijacking the CPU, corrupting your memory stack, and locking up the system with all lights on. • The Fix: If the audio cable is plugged into the Altair but unplugged on the other end, it will collect massive amounts of static. Either unplug the cable completely from the Altair when not in use, or make sure the other end is firmly plugged into a headphone jack (even if nothing is playing) to ground the circuit.
2. Ground Loops with the USB Cable
Because you have both the USB wire and the audio wire plugged into the unit (and likely plugged into the same desktop or laptop PC): • The Glitch: You have created a ground loop. Electrical noise from your PC's power supply travels down the USB ground shielding, through the Altair circuit board, and back out through the audio cable's ground. This creates tiny electrical fluctuations on the Arduino's data bus. When you flip a switch, the Arduino misreads the input or glitches out mid-execution. • The Fix: Unplug the audio cable entirely when you are just playing with front-panel code like Kill the Bit. Only plug it in when you are actively trying to load an audio-based program.
3. The "Sense Switch" Trap
To boot from the audio port, the Altair-Duino uses the rightmost switches (the Sense Switches) to tell the computer, "Hey, look at the audio port for data instead of the SD card." • If you accidently have Switch 12, 13, 14, or 15 flipped up while entering Kill the Bit, the Altair will immediately stop executing your program and freeze while endlessly waiting for an audio signal that never comes. Always ensure all your address/data toggles are completely cleared down before hitting Run! When you run into the freeze, is the audio cable plugged into a computer/phone, or is it just hanging loose? Try unplugging the audio wire completely next time you toggle in Kill the Bit to see if the glitch disappears!
what can I do with the USB cable, when I connect it to my linux computer nothing really happens on the linux computer, other than it powers the arduino
You can use the USB cable as a virtual serial (COM) terminal to interact with CP/M, boot disk images, manage the SD card, and view front-panel switch menus directly from your Linux command line. When you plug the USB cable into a Linux machine, the Arduino Due's native/programming USB port does not pop up a graphical drive because it acts as a USB-to-Serial converter rather than a mass storage device.
What You Can Do via Serial Terminal on Linux
To talk to the Altair-Duino over USB, follow these steps in your Linux terminal: 1. Find your device port: Open a terminal and check which serial device was assigned (it usually appears as /dev/ttyACM0 or /dev/ttyUSB0):bash ls /dev/ttyACM* /dev/ttyUSB* Use code with caution. 2. Launch a serial communication tool: Use screen, minicom, or picocom to connect to the board. The standard baud rate for the Altair-Duino is 115200:bash sudo screen /dev/ttyACM0 115200 Use code with caution. (To exit screen, press Ctrl+A, then K, then Y). 3. Trigger the Front-Panel Menu: • Make sure all front-panel toggles are down. • Press the AUX1 toggle down. • A configuration and options directory will immediately print out on your Linux screen. 4. Manage Disk Images & CP/M: From the terminal menu, you can issue commands to mount and swap virtual 8-inch floppy disk images from the SD card (such as CP/M, Microsoft Disk BASIC, or assembly toolchains) and interact with them as if you were sitting at a 1970s teletype terminal. 5. Re-flash or Update: If you ever want to update the Arduino Due firmware or install a newer release of the Altair-Duino software, you use that same USB connection with the Arduino IDE or a binary upload tool. Do you want help running a specific terminal emulator like screen or minicom in Linux, or are you trying to figure out how to mount a specific CP/M disk image from the SD card? • adwaterandstir.com Getting Started With The Altair-Duino 680 | Adwater & Stir Powering and Connection: Power via rear-panel AC adapter or USB Programming Port (do not use both simultaneously; USB bypasses pow... • adwaterandstir.com Connect via USB | Adwater & Stir - Altair Step-by-Step: * Plug USB cable into computer with the other end connected to your Altair-Duino. (NOTE: the power switch is bypasse... • adwaterandstir.com Install Software | Adwater & Stir Easy Method: Download UploadBinaryDue.zip, connect Arduino via USB to programming port, identify COM port in Device Manager, run c... Show all
do I have to use sudo??
No, you do not have to use sudo every time, and it is actually safer not to. By default, Linux restricts access to serial ports (like /dev/ttyACM0) to administrative users and members of a specific hardware group. If you try to connect without sudo, you will usually get a "Permission Denied" error. You can permanently grant your normal Linux user account permission to access the Altair-Duino by adding yourself to the correct hardware group.
How to skip sudo permanently
Open your terminal and run the following command (this works on Ubuntu, Debian, Mint, Fedora, and most major Linux distributions): bash sudo usermod -aG dialout $USER Use code with caution. (On Arch Linux or Alpine, use uucp instead of dialout: sudo usermod -aG uucp $USER)
Important Next Step
For this change to take effect, Linux needs to reload your user profile. You must log out of your Linux computer and log back in (or completely restart your computer). Once you log back in, your user account will have permanent permission to talk to the Altair-Duino. You can confidently connect using just: bash screen /dev/ttyACM0 115200 Use code with caution. Give that group command a try and log out/in. Let me know if screen successfully opens up a blank terminal window for you without asking for a password!
i mean for this sudo screen /dev/ttyACM0 115200
Name:
Anonymous2026-10-28 20:20
still doesn't work
Ah, the documentation for Chris Davis’s v1.4 firmware reveals a specific shortcut behavior. The step sequence you were trying actually keeps the machine locked in a loop! On the Altair-Duino, you do not use the Examine or Run switches to boot items from that specific text menu. The firmware handles loading and running automatically, but it requires you to push the AUX switch rather than just leaving it down. If it stays locked up with all the lights on, follow this exact loading sequence:
The Correct Menu Boot Sequence
1. Put the Altair into a clean, stopped state: Flip Stop UP, then Reset UP. 2. Set all your data/address switches completely DOWN. 3. Turn to the rightmost switches (0 to 7) and flip Switch 1 UP (matching 00000010 for Kill-the-Bit). 4. The Magic Step: Instead of hitting Examine, look at your AUX1 toggle. • Push AUX1 DOWN and instantly let it spring back up to the middle. • Do not hold it down. Pushing it down and letting go acts as the "Enter" key for the menu. The moment you flick AUX1 down and release it, the firmware will automatically drop the game code straight into the memory registers and hit "Run" for you. The LEDs on your front panel will instantly start flashing and playing the game!
⚠️ If it still freezes with all lights on:
If you do this and the panel immediately solid-lights and locks up anyway, Switch 15 might be flipped up. Because Kill the Bit uses the actual physical switches to play the game, if Switch 15 is up when the game starts, the program instantly registers that a player has "won" or manipulated the bit on the very first clock cycle. This breaks the loop, crashes the emulator code, and leaves all the lights stuck on. Ensure every single toggle switch (0 through 15) is pushed flat down before hitting AUX1. Give that AUX1 tap a shot with all other switches down except for Switch 1. Does the text screen clear out and the front panel spring to life? • YouTube·deramp5113 Altair 8800 - Video #3 - Kill the Bit Game Apr 27, 2013 — Altair 8800 - Video #3 - Kill the Bit Game and then a 10 and a zero 10 and zero 333 377 333 377 252 and 17 252 17 looks good 127 ... 7:40 • retrocmp.de Hardware / Altair-Duino Pro / Front Panel Switches // retrocmp / retro computing AUX1 Switch Functions (Down with SW7-SW0 settings): 00000000 directory, 00000001 calculator, 00000010 Kill-the-Bit, 00000011-00000... • Bryce Automation Altairduino Short Cuts - Bryce Automation VT100 Configuration: Shift-F12 accesses menu for baud rate, composite type, and boot text. Boot Configurations: Hold Deposit switc... Show all
now it works
Awesome! That tap-and-release with AUX1 is the secret handshake for getting things to boot directly from that menu. Now that you have the trick down, you can use that exact same method to explore the other cool programs built into your kit. Whenever you want to try something else, just: 1. Hit Stop, then Reset. 2. Flip the binary switches to match the program you want from the list on your Linux screen. 3. Tap AUX1 down and let it release. For example, if you match the code for Pong (Terminal) (00000100 -> Switch 2 UP, all others down) and tap AUX1, a retro video game will start playing right inside your Linux terminal window! Enjoy playing Kill the Bit without having to cycle the power anymore. Would you like to try loading 4K BASIC next to see how to write a simple program on it, or are you having fun chasing the blinking lights for now?
Name:
Anonymous2026-10-28 20:23
yes
Let’s get 4K BASIC running! This is the exact software that launched Microsoft in 1975. Follow these steps to boot it up and write your first program:
Step 1: The Switch Setup
1. Hit Stop, then Reset on your front panel. 2. Look at your menu on the Linux screen for 4K Basic (00000101). 3. Flip Switch 0 UP and Switch 2 UP (all other switches down). 4. Tap AUX1 DOWN and let it release.
Step 2: Clearing the Terminal Prompts
Look at your Linux terminal. It will instantly clear and ask you a few configuration questions. Because you are using a modern terminal, you can just skip them by pressing Enter: 1. MEMORY SIZE? -> Press Enter 2. TERMINAL WIDTH? -> Press Enter 3. WANT SIN-COS-TAN-ATN? -> Type Y and press Enter You will see: text C3000 BYTES FREE ALTAIR BASIC VERSION 4.0 OK Use code with caution.
Step 3: Write Your First Program
The OK prompt means the Altair is waiting for your commands. Let's write a simple loop. Type these lines into your Linux terminal exactly as shown, pressing Enter after each line: text 10 PRINT "HELLO FROM 1975!" 20 GOTO 10 Use code with caution.
Step 4: Run and Stop It
• To start your program, type RUN and hit Enter. Your screen will instantly flood with text as it runs at lightning speed. • To stop the infinite loop, look at your physical Altair front panel and flip the Stop switch UP. Were you able to get through the prompts to the OK screen? Try typing RUN and let me know if your Linux screen starts scrolling your message!