SimonTrew

Sorry waste of post since Algie obviously already knows all this, having found related posts. I *will* get used to the way this forum is organised, soon enough.

They are for the 1050 drives. It's probably easiest to buy a modern programmer, but if you want to be a purist, most EPROM programmers at that time connected through an RS232 port, which the Ataris have not got. But you can easily make one to work either through the joystick ports (which requires some programming) or through the SIO bus. In theory they work on 12V but in practice 5V is good enough. I did multiple drop-down RS232 and RS422 on some bizarre systems, of course this was 20 years before USB came along, and a long time before Ethernet was popular. It was quite a job, at that time, to balance the levels on the lines when you added another drop. We got there in the end, though. S.

Sorry false post-- was trying to find my way around the site-- got there myself in the end. Please ignore.

No, come to think of it, recursion wasn't allowed, since variables were allocated in fixed memory positions, not on a stack. And indirection on the 650x series was very limited, so to access variables on a moving stack would have been quite a burden. The 650x series had indirect addressing via X and Y registers, one which would go one way and one the other (the Y register was the more useful), IIRC, but it was still rather cumbersome. IIRC, the software stack was used only to push and pop parameters. I was programming in CORAL-66 at the time, for embedded processors, and this had keywords for marking recursive or re-entrant procedures/functions, at that time it was certainly not considered the norm to create a stack frame for each new procedure unless absolutely necessary. The 68000 series had specific instructions for creating and demolishing the stack frame, but even now on the 80x86 series it requires two or three separate instructions.

In the old days, they used to go through an RS232 port-- which of course the Atari 8-bits didn't have but if you want to use your Atari to do it, you can make one fairly easily through either the joystick ports or the Pokey port. The joystick ports are only 5V and RS232 is nominally 12V (IIRC) but in practice most devices will work quite happily at 5V. You can up the voltage using some simple electronics (a couple of Zener diodes should do the trick) but you will have to write the software to drive it, I think I wrote it to come in through the standard entry point for I/O (forget the address, $Exxx something, it was some time ago...)

Ah, have you ever seen the Pig Demo? There was a fantastic demo by the standards of the day called the Big Demo. I wrote a small program, essentially a screensaver, called the Pig Demo, which was just repeated tiles of flying, animated pigs, with rudimentary "oink" noises. It's not particularly brilliant but is quite amusing when you see it for the first time. I think written in pure Assembler, as it was under 2K (including the screen memory required) so could not have been done in PL65. Unfortunately I threw out all my Atari stuff-- one of the few times in my life where I *knew* I'd live to regret it.

Thanks for the welcome! I don't know what's on the LACE disks-- often they were toy examples to try to get people started, rather than particularly useable programs. The main one to try to track down, if it's not already there, is the 8: driver (the 80-column driver) which can be directly substituted for E:. The only thing I should have done to this but didn't, was that the scrolling could be faster by manipulating the display list instead of actually moving the stuff in memory. However, as you might be aware, you have to be careful with the display at that resolution as Antic had certain requirements at (IIRC) 4K boundaries. Of course the fonts are *tiny*, and I believe they displayed worse on NTSC machines than on PAL ones-- someone once provided a substitute font. Nevertheless it was truly useable. I didn't do any commercial work for Ataris at any time-- it was just a hobby. I designed quite a number of fonts-- of course in the limitations of the 8x8 bitmap-- not sure if they're still around. I actually used the Atari to do video captions, end titles etc when I was at school-- so this must be about 1986/87-- and it was quite good at it, with the smooth scrolling etc. By the standards of the day, of course.

Actually yes I remember there were two stacks. There was the hardware stack at $100 and the software stack at $2000. The hardware stack was used for JSR etc (opviously) and the software stack to push parameters, etc. It *did*, if I recall correctly, allow recursion, but obviously not very much. The Kriss Kross example that I mentioned in another post made its own stack since essentially it's a recursive problem (as indeed is Sudoku), and needs a bigger stack than is available, at least for high-speed solutions (or generations). And I think it was a duplicate sector, not a bad sector. S.

I'm sorry I'm new to this forum so didn't realise the chronological order. As far as I recall, the stack does indeed go from $2000 or $2100. This leaves Page 6 free of course. The assembler is actually better in many respects than the Atari Macro Assembler, as far as formatting goes etc. For example you wrote ASLA for arithmetic shift left accumulator because ASL A would be ambiguous if you had a variable called A. (I forget whether variable names were case sensitive.) IMHO it was the most "structured" language available on the market at the time. There was a small run-time library with integer multiplication and division; I don't think floating point was available. The FP, if I recall correctly, was part of the Atari Basic ROM not part of the OS proper. It was awful (a BCD encoding) and I think Turbo Basic sped it up enormously by changing to a binary representation rather than BCD-- again I am just going from memory. Simon Trew.

Hi You mentioned my name in an article (http://www.atariage.com/forums/index.php?showuser=6661) and I found it via Google. To give you some more information, some of which I am sure you already know: BaPAUG was the Bournemouth & Poole Atari Users Group. I lived (and live) north of London, so I never got to see them except at shows; if you Google around a bit you will find a few pictures of me at Stafford, where the shows were generally held, and is utterly dismal. I was closer to LACE (London Atari Computer Enthusiasts); the chairman of which lived in Leytonstone, though it was a fairly wide bunch, with one member living south of the river and we generally met at member’s house in Kensal Green (NW London). We used also to dial in to a BBS in Brum, I forget who ran that, but later LACE ran it. Algie in Kensal Green is the man to contact, but I forget his surname (if I ever knew it). His long-time partner Cat was sweetheart too. As for PL65, it is no doubt derived from PL/M (and unlikely from PL/1, a much more complex language) and was pretty swift. I programmed for PL/960 on truly obscure processors. If you Google around, you will find several programs that I wrote in PL65—none of them my best. It is basically an ALGOL-based language and was advertised in Page 6 and I imagine in Atari User etc. As you suggest, it was somewhat obscure, but considering we had no C or C++ at the time, was better than Atari Basic or even Turbo Basic, for the power user. It will run on standard AtariDOS, you don’t need SpartaDOS. I hope I shan’tbe in trouble for cracking it open! Bit too late now I imagine. If I recall correctly, it was deliberate bad sector, and knocking out the code to read the bad sector made the1 problem go away. As a professional software engineer, I don’t tend to do that kind of thing, since I am simply taking money out of one pocket to put in another, but it was a pain to use before cracking it open, so I did it for my own sake having legitimately bought a copy. I never knowingly gave anyone else a copy, so I can’t imagine how you got hold of it. I can remember most of the details of PL65. It had a distinction between PROC and FUNC, if I recall, and also a very queer feature (which resembles LISP lamda-functions in some respects) whereby a procedure could be passed to another procedure, i.e. the address of it, to save having to push and pop arguments unnecessarily. I also wrote—God knows if you would ever find this—a “defragmenter” that removed all the fragments in assembly language programs and made them much faster to load. AtariDOS had a four-byte header on each segment indicating the length of the segment and its address in memory, which was then followed by the data. This was especially important for PL65 which typically would have 80+ segments. Bear in mind that I had the 6502 instruction set off by heart at that point (and 8086 and 68000 too). I wrote an 80-column emulator which would be nice to find again, and a few demos for LACE that are quite nice. I wrote a prog to solve Kriss Kross puzzles which was probably the first to use a real windowing system on the Atari 8-bits (the prog was more or less a demo of the underlying windowing system), The Cube Demo which demonstrated rotating cubes using the DMI etc (apparently not so good in the US as it only *just* made it under 20ms and with a faster screen refresh rate and slower processor on US machines, would demand two screen cycles), and did other bits and bobs that I can tell you about later. Best Wishes Simon Trew.