Slashdot Mirror
Programming the Commodore 64: the Definitive Guide
Mirk writes "Back in 1985 it was possible to understand the whole computer, from the hardware up through device drivers and the kernel through to the high-level language that came burned into the ROMs (even if it was only Microsoft BASIC). The Reinvigorated Programmer revisits R. C. West's classic and exhaustive book Programming the Commodore 64 and laments the decline of that sort of comprehensive Deep Knowing."
Atari 800 rules!
Expert Java EE Consulting
Oh what fun raster interrupts were.
Now, I can finally stop waiting and get to programming my Commodore 64!
You see? You see? Your stupid minds! Stupid! Stupid!
I started on a Commodore 64 (well a Commodore 128 that ran exclusively in 64 mode..) and learned machine language by breaking protections of the day. Many of the things that were legal back then such as copying software for DRM'd games are now gone the way of the dodo. I honestly see that in twenty years from now a debugger in itself will be seen as a "tool of crime" or whatever wordage they use to keep them out of the general public's hands just like lock-picks today. Hope you like high-level because the day is coming that it will be illegal to be low-level without a government (or more likely Apple) license.
Shh.
Yeah, because drivers and kernels are perfect and never have bugs.
Here in 2010 it's not necessary to understand the whole computer
Unless you want more throughput: manipulate more objects at once, serve more users at once, etc. If a Python program is spending most of its time in interpreter overhead, you may need to recode inner loops in C.
Or unless you're programming for an 8-bit microcontroller roughly as powerful as a Commodore PET. Not all "computers" are as powerful as PCs or even smartphones.
Relax. You've obviously read too many kdawson stories recently, and have been trolled into a heightened state of paranoia. Don't worry, it happens to the best of us.
Also, why have you switched off your iphone citizen 533448?
It was possible to fully understand all of the old 8 and 16 but machines. Now you could spend momths trying to fully understand one video card, which would be replaced by something more complex by the time you finished understanding it.
And that was a big part of it, the stability of the platforms during that era. A C64 was exactly the same as every other one, a Tandy Coco was identical to the million others of it's kind. Later models tended to retain as close to 100% backward compatibility as possible so knowledge and software tools retained value. Now you buy a lot of PCs with the understanding that a year from now you won't be able to buy more of the exact model even if you stick to Optiplexes and such that promote the relative stability of the platform. Something will be slightly different. So, understanding being impossible we abstract it all away to the greatest extent possible.
If you want to reconnect with low level look at AVR microcontrollers. If you are really frugal you can get going for $20.
Democrat delenda est
Though my experience was on the Apple II not the Commodore. Little things like writing your own device drivers, drawing graphics via direct access to interlaces vram, (oh the maths!) direct read latch access to the floppy drives, writing hybrid assembly/BASIC apps. It was grand.
It's downright depressing to compare my present-day knowledge of computers, classify myself as somewhere in the upper 2%, and still wish I knew a quarter as much (percentage-wise) about my current computer as I did about my //c.
*sigh*
I work for the Department of Redundancy Department.
But.......anyone who would have trouble going without garbage collection, and couldn't learn how to code on a C64 probably shouldn't have a job. And anyone who can code on a C64 should have no problem adjusting to garbage collection.
Qxe4
Today we have garbage collectiors in Java
Garbage collectors in Java are good for collecting objects that own only memory but lousy for collecting objects that own resources other than memory. Resource leaks happen whenever someone forgets to close() something in a finally block, just as they do in C++ when someone forgets to delete or delete[] in a destructor or in the exceptional path of a constructor.
Everyone who still writes code on the C64 instead of Java won't get a job.
Unless you're in charge of making a PC or phone port of classic C64 games. Then you need to know both Java and C64 assembly language.
All the stuff we learned on the VIC-20 and Commodore 64 (and PET) still applies in the embedded world. If you could program them, you can totally do a PIC or an Atmel AVR (or Arduino).
...buy yourself some Atmel microcontrollers (ATMega8 is a good choice). This will be instantly familiar to anyone who programmed assembly language on the C64. There are some differences, the Atmels aren't Von-Neumann architecture but Harvard architecture (separate program and data address space) and the CPU has more registers, but there is excellent hardware documentation, the complete command set and detailed register descriptions in the data sheet. There are lots of interesting application notes (IR decoding, interfacing to PS/2 keyboards, LCD output, ...). The Arduino system is based on an Atmel microcontroller, so there is also a big application oriented community in addition to the people coming from the electronics side.
It's not a toy either. These controllers are everywhere. Have fun and learn a useful skill...
Here in 2010 it's not necessary to understand the whole computer, from the hardware up through device drivers and the kernel through to the high-level language that came from your apt repositories.
It wasn't necessary then either. The point is that you could. Now this is no longer possible. There are pros and cons to this, we can acheive more by building on the magical black boxes, but there was something deeply satisfying about knowing a device in such depth. The same can still be acheived in the embedded realm, however, and due to modern advances, it's cheaper and smaller than ever!
To know a computer from the ground up, as it were. Its not some long lost dream or anything, after all your average disposable Crapple Netbook with "clout computing" or Octocore Core i13 and a half is just a fancy C64 with more CPU instructions, more memory, more peripherals that runs faster.
Its just that unless you start off at the low level, learning about transistors and that sort of shizzle and learning assembly language you probably will never bother to learn it. A lot of programmers now think about functions, objects and arrays as if they actually exists - not just a convenient way of presenting blocks of code and data in a way that makes it easy for you to understand. Fuck it, a lot of people fairly high up on the IT scene have no clue in the wide world about TCP or UDP but they sure as hell know how to write a 'Web App' using JSON and the latest Web 2.5 gimmick completely oblivious to any of the lower levels.
The problem is when you have nearly everyone going for the latest abstraction layer, easy low hanging fruits (at the expense of efficiency and everything else - rabble rabble rabble) high level stuff there might be a day 2110 when they're still using HTTP + more abstraction layers but quantum computers aren't getting any faster for what they need and nobody knows knows any of the low-level stuff anymore. If you are the one kid on the block who knows how to write assembly in 2110 you'll be a rich man by 2111, just in time for the end of the world cause the Mayans were off by 100 years.
It's lovely to remember what was, but not so great to forget what we have today.
Sure, we generally don't know the whole widget from top to bottom, but it's a hell of a lot easier to get a program up and running. It's not just frameworks either - the choice of languages we have today beats the crappy BASIC we had then, or the assembly language tools we had.
The first machine I knew inside-out was the ZX-Spectrum. While I like to remember it fondly, I would never want a return to those primitive times.
It's a bit like object-oriented programming - we hide the details of an object and only deal with the interface. It's more scalable and leads to faster development.
for certain the drivers/os back then were less buggy - they were smaller and so much less complex. It was a fairly simple matter for someone to have full understanding of the entire OS and sum it up in under 50k. (and I mean BYTES, not LoC)
I work for the Department of Redundancy Department.
One of the most comprehensive protections at that time was called "V-Max!" which stood for Verify Maximum. What were called "nibblers" for disc copy software couldn't touch it even though those nibblers represented the ultimate in disk copy technology at the time. There were two ways to copy V-Max, the first was to get a dedicated hardware copying unit. The second was to apply a bit of knowledge with a debugger cartridge: the V-Max protection was a turn-key system you gave them files and they wrapped the protection around it and provided a fast-loader at the same time. So what you would do is fill all of memory (the whole 64K) with a value you knew say: $AF. Then you would load a V-Max file from the disc, it's loader would automatically take over and while it was loading you would enter your debugger cartridge and change it's exit point to point to itself. So instead of $0800: RTS you would make it $0800: JMP $0800. Then you would wait for the V-Max loader to fully load the file. Then a quick button press on your debugger cartridge and use the memory monitor to find where the file loaded by seeing what memory was NOT $AF. Then from the debugger cartridge save that memory block out again. Completely de-protected file. Since V-Max used standard kernel-load vectors the program itself needed no further modification, the protection was completely gone you just lost the fast-loader function. Which you then re-added yourself into a chunk of memory wherever the game didn't use it. Relocatable code was best for that. Later versions of V-Max also did on-the-fly decompression of files so occasionally while stripping the protection you would run into a situation where your destination disk ran out of space versus the original protected disk. Again, that was worked around by inserting your own custom loader into the kernel load-vectors which also did decompression. V-Max was impossible for copy software of the day to copy but with a little bit of knowledge and a debugger cartridge it was absolutely trivial to defeat.
Shh.
Why "lament the decline of that kind of deep knowing?" Shouldn't we just encourage teens, students, hobbyists, computer science majors (e.g., anyone with an interest in this kind of thing) to get out there and buy a C64 or a kit or an open source game machine or an embedded device or any of the other numerous projects in which we could pursue "deep knowing"?
Frankly, it's a great time to be interested in computers: absurd amounts of power for cheap, _along with_ easy access (thank you Internet) to kits, information, software, books, older devices, embedded devices, game devices, community help, etc.
It doesn't have to be either or.
Should anyone wish to download an electronic copy (PDF) of Programming the Commodore 64 by R. C. West they may do so from DLH's Commodore Archive. It's a community supported archive of Commodore-related printed materials (books, magazines, newsletters, manuals etc.) and it could use your support. Enjoy.
This guide is *GREAT!*
I've got 6 web sites and 25 mission critical apps running on a cluster of 10 Commodore 64s. It started out with just one, but as our business expanded, we just kept adding them on. It would be a bear to migrate to MS-DOS or Windows 1.0, but maybe it's time. The acoustic coupler modem is a bit slow, but it's been working for us since 1990, it's hard to justify the upgrage.
If you want news from today, you have to come back tomorrow.
The lady doth protest too much, methinks.
And why did I spend time removing protection systems? Funny that part is: I owned an MSD floppy drive which was completely incompatible at a machine-language level with the 1541 drives everyone else owned and that all the game-makers wrote their protection systems for. So my floppy drive would load any of the software of the day. I literally bought a game, had to hack away the protection, and then I could play it on my computer. Of course no one will believe me when I say this but damnit, its the truth! Now get off my lawn.
Shh.
I credit going through elementary school with a Commodore 64, one of the few in my school that couldn't actually afford one, for my advanced engineer position I have now. I spent so much time hacking away basic programs and stuff that I ended up learning so much computer science without even realizing.
Its the only explanation I have for how I've been a software engineer for my entire post school career (the past dozen plus years) while my undergrad degree was a BA in English.
"Where is my mind?"
I sometimes wax for the simplicity and deep understanding of the machines that I grew up with, but, the fact is, today's PCs just do more. They aren't just faster and more memory, they are also that much more complex. Sure, the instruction set of AMD64 is not that much more than the instruction set of an older machine, but that's only because its suffficiently well organized between opcodes and address modes that you can learn it. But after that, there's the whole peripheral story. How many people -really- want to know the ins and outs of how a PC Express bus works. Or USB. Forget video cards - what about sound cards. Even with data sheets programming a driver is a tremendous challenge.
And that's just at a hardware level. I mean, seriously, it wasn't that uncommon for people to write line editor or field editors for 8 bit machines or even for DOS text mode, but that's because everything was fixed width and height and you controlled everything, even the cursor. Nowadays, I doubt there's but a handful of genuine home grown edit controls for GUI environments - everyone just uses the widget that comes with it, and for good reason - they are mind boggingly complex for such a seemingly simple thing. You have to know about the current font, the events with the mouse, keyboard...you could easily blow a 1000 lines of code on it.
This is my sig.
I make a lot more doing embedded work (last year I did a job on the 6502) than I would make with java.
Do you even lift?
These aren't the 'roids you're looking for.
I've been waiting for this guide... like... forever. Now I can finally finish that work project
Let's celebrate the rise of this sort of universal "accessibility" which leads to more viruses, more "PC" stores like Best Buy/Geek Squad and in general the decline of the computer. Yeah, its great if you are like Geek Squad and can charge $50 to plug in a USB cable and install drivers ( see http://www.geeksquad.com/services/computer/service.aspx?id=2927 ) for everyone else? It is a nightmare.
Taxation is legalized theft, no more, no less.
Even in those days I am sure there were lusers happily doing their jobs on a VT100 or similar terminal. Starting with a menu or simple command set was not so different from a GUI today.
http://michaelsmith.id.au
Absolutely. This is the point of, for example, the STEPS project at VPRI, which aims to build an entire working system (kernel, GUI, dev tools, apps) in under 20,000 lines of code. Some of the stuff they've produced, like OMeta and COLA are really impressive.
Adding complexity to a system is easy. Adding features without increasing the complexity is much harder, but much more useful and rewarding.
I am TheRaven on Soylent News
Fast loaders worked because the kernel ROM software didn't fully take advantage of the hardware. Between the C64 and the 1541 floppy drive the connector cable had 4 wires for carrying information. The kernel routines built into ROM only used one of those lines to signal from the drive to the computer. The "fast loaders" simply uploaded a program to the drive which used all four lines to signal information. The "fast" loaders weren't fast magic they just removed a deficiency in the kernel ROM routines. The exact number of lines between the computer and drive I'm not sure of but this is the principle the fast loaders worked by. And tape based fast loaders worked because the kernel routines would save a copy of the information to tape and then immediately save a complete other copy to compare against for error correction on load. The tape fast loaders just skipped saving and comparing the redundant copy to get the speed. Disk fast loaders didn't compromise the integrity of the information in the way tape fast loaders had potential to though. Remember computers back then were full of noise when you were talking to tape drives especially.
Shh.
Typing in programs line by line from a book or from Compute! Gazette to animate a moon landing, or play Basketball Sam and Ed (I think they were called).
:(
Anyway, even Mad Magazine eventually published a program, but it never worked.
You never expect irony, do you?
Want to be a professional wrestler? Visit www.iyfwrestling.com
@iyfwrestling
http://www.salon.com/21st/feature/1998/05/cov_12feature.html
Ellen Ullman was a programmer for a full career before she discovered she was also a talented writer. The above link is to a Salon.com article that was basically an excerpt from her excellent book, "Close to the Machine".
She writes about getting a PC and stripping off Windows, DOS, everything, until the (old even for 1998) BIOS is saying "Basic Not Loaded", then building Linux on it.
Her conclusions do sound a smidge "kids these days" when she writes about modern programmers that only know libraries and IDEs, but I know the /. gang will love it:
"Most of the programming team consisted of programmers who had great facility with Windows, Microsoft Visual C++ and the Foundation Classes. In no time at all, it seemed, they had generated many screenfuls of windows and toolbars and dialogs, all with connections to networks and data sources, thousands and thousands of lines of code. But when the inevitable difficulties of debugging came, they seemed at sea. In the face of the usual weird and unexplainable outcomes, they stood a bit agog. It was left to the UNIX-trained programmers to fix things. The UNIX team members were accustomed to having to know. Their view of programming as language-as-text gave them the patience to look slowly through the code. In the end, the overall "productivity" of the system, the fact that it came into being at all, was the handiwork not of tools that sought to make programming seem easy, but the work of engineers who had no fear of "hard."
---
I do recall some /. (or maybe it's in Salon) commenter at the time who replied, "Yeah, and your Dad thinks you're a weenie because you don't know how to wire transistors on a circuit board, and his Dad thinks he's a weenie because he can't wind the copper wire around his own inductors". Which is fair enough. Even log cabins can't be made without manufactured tools unless you can mold a kiln from clay and smelt iron for the axe yourself.
Still, the point of the desire is to have *maximum* control of the level of tool you are able to work directly with. The philosophy was echoed by Neal Stephenson in his essay, "In the Beginning Was the Command Line", the googling of which I will leave to the student. It's on-line.
..., almost like finding a long lost and cherished childhood toy. I remember my Apple II days, programming assembler, writing routines to directly address the disk drives. Then my project for the computer science class we had in High School (Germany 1984), where I had gotten my hands on a disassembly of the entire ROMs and from that figuring out how the mathematical formula interpretation worked (simulated stack and all). Finally, a year later, getting my hands on the schematics and figuring out how the video logic actually worked. Only once did I feel that powerful again in my life, when I recreated that feeling in 1996 by designing, building and programming an embedded 68000 computer for a piece of medical diagnostic equipment. Designed the system, built the prototype, debugged the hardware, routed the PCB (by hand, we had no money), wrote a round-robin multitasking system in assembler and finally the actual application as well. Still have a copy. That, and the discovery of sex :)
Probably, but the Basic was written by Microsoft, and the ROM took 16 Kb (not counting the code when using a disk-drive).
Since an opcode is between 1 and 3 bytes, there would be around 8000 to 10000 LoC.
FTFY.
Yes, I know it's harder, but it's the Right Way(TM), in my humble opinion.
Dilbert RSS feed
Dude, back when I was a kid and had a C-64, I wrote a JVM for it. Unfortunately I had trouble, because while the JVM standard defines long as not being threadsafe (as a sop to 32-bit architectures), it defines operations on int, short, char, and Object references as being atomic. So I had to write single-threaded code to simulate multiple threads just to get the garbage collection to work. And my char mappings didn't support Arabic and Chinese- you had to stick with PETSCII.
I was so embarrassed in front of my friends when my games paused intermittently to clear out kilobytes of garbage from the little heap. They were like, WTF, what is it doing, and I said, give me a break, it's Java. The only program I ever really got to work right was my C-64 emulator.
FTFY.
Yes, I know it's harder, but it's the Right Way(TM), in my humble opinion.
I didn't think the official Python implementation had a JIT compiler.
[b.belong('us') for b in bases if b.owner() == 'you']
Today we have garbage collectiors in Java and that is why the C64 is completely outdated.
Everyone who still writes code on the C64 instead of Java won't get a job.
You probably don't even know the latest words.
Oh, I don't know about that. There are thousands of embedded systems that need programming and require the kind of thorough knowledge of the hardware that you got from the old C64 days. There are more 8-, 16- and 32-bit systems without enough memory to run something like Java than there are PCs and higher class systems.
Don't pooh-pooh the old ways. They're what's running your world.
Who said you needed to use the official Python implementation?
Dilbert RSS feed
BZZZZZT! You have failed your retro recollections. The C64 WAS single thread and all byte/word ops were atomic. If you want threaded code, use FORTH. Remember to push x/y/a/s on a context switch.
Two be specific the 16K of ROM was split into 8K for the Basic ROM and 8K for the Kernel ROM.
Shh.
The deep knowledge is still there - the well is just a LOT deeper, and more complex.
In the days of the C64 - it was reasonable for a skilled and/or curious programmer to get to the bottom of things and learn how everything worked, exactly. It was also potentially USEFUL for him to do this.... it was the only direction you could go, short of inventing a new language.
So - today we still find deep knowledge out there - but it just not be as useful for even a very good programmer to go ALL the way down.
Yes, a Java programmer should know more than just the surface - and more than just the patterns. He could also go deeper and understand the JVM implementation, and to a degree how it uses actual machine resources - but to suggest he needs to all the way down the rabbit hole is taking it a bit far.
My point, I guess, is that there is no need to pine for the old days - nobody says you can't learn more and go deep, and those who do, tend to prosper.
I had a 1 line game for the commodore series of computers.
Something like the below. You could do it in less than 40 characters with the short cuts. It even worked on the TRS80 line with slight modifications.
I liked walking into their sales rooms with the "don't touch serious stuff" feel and having a game going in 30 seconds.
0 poke 32788+loc,65; loc=loc+peek(151)*2-1; print tab(rand(37)),"XXX"; if peek(32788+loc) == 32 GOTO 0
You had to clear the screen and start it with RUN at the bottom for it to work
poke 32788+loc,65 # Display your lander "A" at the middle top of the screen+ offset
loc=loc+peek(151)*2-1 # update your location to the right if shift is pressed, otherwise to the left. No going straight.
print "XXX" # but a block XXX at the bottom of the screen and scroll the previous display of your lander A off the top
# the blocks would scroll up towards the top of the screen and you had to dodge them
if peek() # loop if you are not going to hit a block
It ran nice and fast.
I had the monochrome green on black monitor that came with the set up. I remember the huge boxes that the computer & the separate one for the monitor was in. (Compared to the slim box that my MacBook Pro came in.) I loved peeking and poking my way through programming in AppleSoft Basic. I even cut my teeth learning assembly. It was fun! It was what I loved about learning to program. This article reminded my of the long gone days. I still enjoy learning new languages but I miss my Apple ][e in so many ways.
Save Pangaea!! Stop Continental Drift!!
Th C=64 was the first computer I owned that I diden't build from scratch AND it had a disk operating system such as it was... Those were good times.
I still have the hesware 46 forth cartridge for the 64.
(I came across it recently in a box full of old junk, manual too.)
I used to love forth but write only languages are such a pain even for the original developer.
I cant imagine trying to maintain someone elses forth code.
Machine code was so much easier.
Anyway, I salute you Tom Zimmer, wherever you are.
Wow that was easy, http://tomzimmer.blogspot.com/
Wear knickerbockers?
Tie an onion to your belt?
Change happens, embrace it, or go the way of the dinosaur.
I want to delete my account but Slashdot doesn't allow it.
well I was just thinking about applesoft... it occupied $B600-FFFF iiirc, about 18k. DOS for the floppy took just above the card rom all the way up to that, which was what, $D000-$B5FF, about another 12k.
I had a sourced copy of both somewhere around here. Was fun to be able to recompile your BASIC or DOS. (ty BB) People today with their kernel recompiles have no idea they're not the only ones doing that sort of thing.
I work for the Department of Redundancy Department.
Unless you want more throughput: manipulate more objects at once, serve more users at once, etc. If a Python program is spending most of its time in interpreter overhead, you may need to recode inner loops in C.
Instead of going through the expensive and painful process of rewriting parts of your application in a more efficient manner, you could also just through more machines in your server rack and be done with it. Adding/upgrading servers if often a lot cheaper than optimizing your code, and also introduces less new bugs.
Pretty good is actually pretty bad.
Google Manchester Baby Mark 1 "programming contest".
This /. article from 2008.
Now that was a machine you could wrap your head around and actually write bug-free code for!
Pot noodles anyone? *inside joke*
Knowledge is how to play a game, intelligence is how to win, wisdom is knowing what game to play.
A few years ago when I was an undergrad, I did a class project on the C64 just for the hell of it...the assignment was for my Theory of Computation class, and I happened to be taking an embedded systems class at the same time. I ended up implementing a Turing Machine simulator on the C64. I used a C cross-compiler on my PC to develop it, tested it on an emulator, and eventually burned it onto a ROM chip which I put into an actual cartridge that ran on a real C64. It was a REALLY cool project that involved quite a few different aspects of CS, and I ended up taking first place at a undergrad research poster competition at a CS conference.
What the hell? The Commodore's BASIC interpreter was not Microsoft BASIC. It was just the Commodore's variant of the BASIC language. Microsoft had not a bloody thing to do with it.
I've recently rediscovered the joy of small computers that can be fully understood by one person. The 8 bit machines from the 80s provide opportunities for learning and experimentation that are not present in today's computers. "Retro computing" is growing as a hobby amongst both people who remember these machines fondly from past days and younger folks who just find them interesting. It is strictly a hobby of course, very little "useful" stuff can be done with these boxes beyond the education they can provide.
My favorite retro system is OS-9, a real time multitasking operating system that you can fit in your head. There is an open source version called NitrOS-9 which has excellent documentation and most of the code well commented. It runs on 6809 based computers like the Tandy Color Computer and the Tano Dragon.
You can learn a tremendous amount about process scheduling, IPC, memory management, device drivers and low level I/O, etc from playing with this system.
-Lod
Yeah but I was running a ribbon cable to my brother's VIC-20 for the garbage collection and extra 5K heap memory because I couldn't get my dad to buy me three more C-64 machines for a quad-core 32-bit CPU. He kept saying, there's nowhere to plug them in; just wait for the C-128 to come out. I was like "but Daaaad, it only has 8 bits!"
Cloud computing was really difficult too. There were a bunch of kids in my highschool running BBS systems but you couldn't really store your documents there because you always got busy signals, the 300 baud VIC modem was a POS, and the cloud had nothing but stupid foul-mouthed kids in it anyway.
Th C=64 was the first computer I owned that I didn't build from scratch AND it had a disk operating system such as it was... Those were good times.
My first was a VIC-20, hardware-hacked from an article in 73 magazine to fill in the 'missing' chunk of memory. Hacked a few games and wrote a bunch of BASIC stuff. It served faithfully for RTTY and slow-scan TV and a second VIC20 controlled a Yaesu FT-757 transceiver including pre-programmed 10M FM repeater splits. Never did 'upgrade' to the C64.
"I believe in Karma. That means I can do bad things to people all day long and I assume they deserve it." : Dogbert
This is a must read for anyone interested in Commodore and its products, a great historical account how among other things the C64 came to be.
http://www.amazon.com/Edge-Spectacular-Rise-Fall-Commodore/dp/0973864907
http://www.intellipool.se/ - Intellipool Network Monitor
...at age 12
allowed me to make my own databases
graphic animations and even up and down moving sprites
i even parsed commands to do htngs like move an army and make a hockey game and boxing game.
12
what do your kids do
besides twitter , waste money on phones , and use myspace and facebook
Microsoft only programmed Version 1 of Basic for the Pet, the programmers at Commodore programmed version 2-10, v7 was the C128 and v10 was C65.
If you had any idea how hard I'm laughing... thanks :)
Here in 2010 it's not necessary to understand the whole computer
Strawman. No one claimed it was necessary, or that being necessary is a prereq for wanting to do it.
So does anyone know what Raeto West went on to? I had Programming the Pet-CBM and Programming the Vic20, predecessors to the book in the article, and they were probably the most authoratitive sources for those systems. Rae also had the excellent "Dear Rae" column in CCI magazine.
But unlike the esteemed Jim Butterfield, Rae sort of disappeared from the scene. A real shame.
POKE 36879,8
The funny thing is that I don't know how memory management works in BASIC. It somehow never really seemed to be an issue. Even in assembly I didn't seem to have to think about it a lot. It's only when I started to program in C that I really woke up to the issues. Granted, all that is _way_ before I actually had the opportunity to take any classes on programming and programming languages.
But now I am curious. How _did_ memory management work on those old BASICs?
Please correct me if I got my facts wrong.
50k Libraries of Congress would be quite a bit. Almost the size of Windows 7 code I imagine.
...for example, I go over mechanical stuff very thouroughly to know how it works.
But even then, I don't know _exactly_ why steel is more durable than iron. As in on the molecular, atomar and sub-atomar levels. You have to draw the line _somewhere_.
And if I have to choose between a C64 I can understand completely (for some value of) and the Thinkpad 201s I have been drooling over recently... Well...
The Commodore VIC-20 was sold by the Shat [..] Final score Commodore- over 9000
Hmm, was William Shatner related to Vegeta by any chance?
"Slashdot - News and Chat Sites Deviant". (Click "homepage" link above for details).
I also have this desire. And it alternately gets me in trouble or lets me write really good code. It also lets me detect when a system is so poorly documented that nobody really understands the impact of the changes they're making to it.
When I worked at Amazon, my desire to fully understand the system I was working on really got in my way. About the only system I could really effectively work on was one I wrote myself.
Need a Python, C++, Unix, Linux develop
This is the end of the computer era. We're still using them because nobody has come up with anything new, but it's an exception. Computer desktops are becoming more streamlined, easier to lock down, and focused on a handful of applications. The web browser and browser-apps is replacing the little "one off" freeware apps. Sure you may need a local office suite for heavy processing, but you can get by with far fewer applications installed than 10 years ago.
10 years ago, I'd have Finger, Whois, Telnet, Ping, Traceroute, FTP, etc. clients on a Windows desktop. Now if I'm on OS X or Linux, I have them, if I'm on Windows at the office, I run them web based if I need them.
For home computing, I don't even have a "home computer" anymore. I have one in the home office, but it's purpose is primarily working from home, not "general computer." Between the Blackberry, iPad, iPhone, etc., all these different components take over our computing needs as inexpensive special purpose machines.
Remember, in the early microprocessing days, it was exciting to get a computer for $2000, probably $10k in today's dollars 25 years later. For that kind of money, it was important to do EVERYTHING. Now we buy a platform for 2%-4% of a 286 computer (in real terms), so who cares if it does everything or just runs apps from the Apple store. I could buy 25 computing devices and have less money invested than I would have to have a Mac AND an "IBM Compatible."
You didn't have to worry about allocating/deallocating because you were the sole owner of the computer. All memory was yours. All variables were global, and stayed in memory for the duration of the program. On the C64 you could also directly access RAM by address from BASIC, I'm pretty sure you could do the same from most other systems' basic.
Qxe4
We're using "yesterday's terminology" here. For the purposes of computer app size, LoC is Lines of Code, not Libraries of Congress.
I work for the Department of Redundancy Department.
amen
GENERATION O98346: The first time you see this, copy it into your sig and remove a random number from the generation. T
The problem is that they can't stop to listen.
Steve's Computer Service, Hobbs, NM
Please somebody mod this up and restore my faith in slashdot.
This is a must read for anyone interested in Commodore and its products, a great historical account how among other things the C64 came to be. Tiffany NeckLaces Tiffany Rings Tiffany Gift Wholesale tiffany jewelry Cheap tiffany jewelry Discount tiffany jewelry http://www.mytiffanycvs.com/