วีดีโอ

Yummy 😋

I do landscaping now so I only gotta talk to one person. No more useless meetings. Yes, I'm down for this ride. Holla when you spin da block on Fortran.

The Atari 800 and 400 had a "memo pad" mode where you could just type stuff on the screen. You enabled it by starting up the computer with no cartridge inserted and no disk or cassette drive running. That meant no way to save it either, though, so it had limited utility. Later XL and XE models dropped this. Since BASIC was in ROM, in effect, it always had a BASIC cartridge inserted if no other cartridge was inserted. You could bypass BASIC by starting up with the "option" key pressed, but this would put it in to diagnostic mode instead of the memo pad.

Cool, can you do learning video on how to use and understand flake-parts? A lot of documentations would be nice to bring it to life ie bring it to action via video

Not sure why moving the cursor doesn't work for you, maybe you are using the cursor keys in the numpad? That doesn't work for me, even with num lock off. What I use are the proper arrow keys, hope that works!

Server side web development isn't so bad. Client side stuff sucks though. JavaScript's ecosystem is... baroque. I mostly keep to HTMX or Preact, depending on the circumstances, ideally the former. At least with HTMX, the client side of things is a really thin layer.

thank you for the vid. I like 6502 and I admire Atari 8bit, Commodore 64 and Apple II computers. I don't have the last one but I'd like to poses this machine the most. Cheers! "It's fun being frustrated" XD - I think, not so much ;) th-cam.com/video/eQu4aYN2kOU/w-d-xo.html

This channel is the best finding this year so far. Keep posting cool videos 👏

sfbj = spool-files-by-jobid sfbi = spool-file-by-id

<-- Pascal contractor. good effort

hey i just saw your channel… Really loving your content.. would be commenting here from now on

Should I learn cobol? Can I get a job without proper experience in a professional Environment? I mean ofc i can learn the basics, but will it be enough for a 90k€ job? 😂

One more thing that I just remembered, this chapter also asks the reader to save an obj file. It is explained in a previous chapter that you can do this with the BSAVE command if you know the start and end addresses of the program, something along the lines of "BSAVE #D2:NAME.OBJ<START,END". If you don't feel like figuring out these addresses, you can simply assembly the program into an object file directly, instead of assembling it to memory first and then copying the memory to a file, with the command "ASM ,,#D2:NAME.OBJ". I've learned this, and many more things about MAC/65 and the Atari computers in general, in the following channel, which I very much recommend: th-cam.com/video/7WdSPvqSIME/w-d-xo.html

Another thing that I noticed is that when you make a mistake on a line you type it again. You might find it easier to just use the arrow keys to move the cursor to the line that you want to change, do the edit and then just press enter again, this will override the previous line with the new one. You can use the insert and delete keys to add or remove characters, and anything else that you press will just override the previous characters.

Hi Ellyse, thanks for another fun episode. Regarding how to inspect the output of the ASM command, I could be wrong since I don't know much about Atari computers, but I think there is no way to scroll up, after a line is gone from the screen it is gone for good. What you can do is press F8 to pause, and F8 again to resume. Pressing F7 will stop the assembly process. You can use both keys in the same way for the LIST command. I think the reason why the directive .OPT OBJ is not present in the listing is that the book is meant to cover both the Atari assembler and MAC/65, so it only uses statements that work for both and probably the Atari assembler will assemble to memory by default. If I remember correctly, the book explains this directive with the first listing and expects that you add it yourself to any other listing after that if needed. A similar thing could be happening with very verbose statements like LDA #TXTBUF&255 and LDA #TXTBUF/256, which are meant to do load into the accumulator the least significative and most significative bytes of the memory address represented by the TXTBUF label. This can be done in a more concise way in MAC/65 with LDA#<TXTBUF and LDA#>TXTBUF, probably the Atari assembler uses a different syntax for this, so the book goes for a syntax that works with both, even if it's a bit awkward.

I enjoyed this

Again, thanks for doing this. I was yelling at my phone as i saw you typing list instead of enter.. NOOOO!!!, oops. Remember, its the journey, not the destination that matters.

Thanks for doing this. I'll be watching more.. in 1980 an Atari 400 was under the Christmas tree and i was hooked on 6502 ever since. I find your pace and fresh look at the topic to be helpful.

Damn i am late

Out of college I had an interview at a company that wanted to hire me to do Cobol. I said, "I don't know it, but I'd be happy to do it." The woman interviewing me cautioned me, "maybe you should go look at some of it before you commit to that idea" and I'm so glad she did. I took one look at it and said, "hell no"

TBH, indirect addressing with JMP isn't super useful unless you're writing an OS and want to provide locations with jump vectors on various events (such as NMIs or IRQs on I/O events, &c.) or the like.

The 6502 would very much be hard mode for anything like AoC! Something like a 6809 or Z80 world be much easier 8-bit CPUs to work with, though personally I'd go for something like 68000 or ARMv2/ARMv3, as both of those at least have nice things like a decent set of 32-bit registers, multiplication, and so forth. The earlier ARM ISA is heavily inspired by the 6502, and it's something a person can keep in their head. A bonus is that if you run an Acorn Archimedes emulator, it has BBC BASIC as part of it, which has a built-in macro assembler! It's '80s/'90s technology, so I don't think it's cheating!

Zero page addressing is one of the ways that the 6502 compensates for having so few registers. Indexed indirect addressing is probably the least useful mode, but indirect indexed addressing is super useful for doing array lookups and the like. I don't think I ever came across a good reason to use indexed indirect addressing, though I'm sure there's some reason to want to be able to address random bits of memory based off of an index register.

For goodness sake, little endian is not "reverse order" it's the order that make more sense for numerical values.

Wow, great job getting through that bowl of spaghetti! I completely feel your pain. And if I had been in your shoes, when getting that "file not found" trying to run bug65 I would have cried or thrown the computer in the bin. :) While it was super frustrating for you, I'm glad you've stuck it out, because showing how you failed and troubleshooted (troubleshot?) the problem is very valuable. So many programming books of that era just had glaring gaps, errors, or misinformation that it astounds me. Like in this case, every version of Mac/65 I've seen comes with DDT. It feels like the version that came with Bug/65 was a very specific version, but how would people at the time known that? If we didn't have the luxury of the internet, this would have been several trips to the computer shop, ringing or writing a letter to the makers of Mac/65 and the publishers of the book and waiting weeks for each response. Or in my case because I was young and in a different country (so couldn't call and didn't think to write), I just shelved the books and hoped my parents didn't notice they wasted money on something I never looked at again. My experience around 1990 of an Amiga assembly programming book was similar to yours here, but I had a completely different assembler and didn't know that each assembler had its own directives and commands. I couldn't download an assembler to match the book, I had to go and physically buy it, but didn't have the money or the money to buy another book.

My only assembly experience was from courses back in university and I forgot most of it, but one thing I remember is that you would pass arguments to subroutines via the stack. That last example finally looked like a real subroutine to be used in a bigger program, it's getting exciting :)

K-rad elite!

Love this so much!

Interesting and ambitious enough to stop in. Hello

I Don't know who this person is. Seeing her stream for the first time. Being very honest here, This is quality❤. She is one of the very few creators who are doing low level programming stuff. Thank you.

I tried that same IBM course and got about as far before switching to gnucobol which I could get basically working in far less time.

This is what I really needed to continue learning Elixir, .exs is a very interesting language

Another thing that might be worth considering is to use the SAVE and LOAD commands instead of LIST and ENTER, which are much harder to get right. Since these commands work with a tokenized format, the resulting file should be smaller, which likely means it will be processed faster as well. I'm not sure if it's customary to use a different extension than SRC for this format, but I've seen M65 used before.

The DATMOV routine did not work properly because what is stored at address $600 is a string, and the routine code only starts after the string ends. The .BYTE directive simply places bytes in memory one after the other, it's up to you to decide if they are meant to be interpreted as code or data. What happens when you tell the 6502 to start executing code at $600 is that it will interpret the characters of the string as instructions, which for all practical purposes is garbage. Atari roots seems like a good book so far, but I think this example doesn't help the reader very much. Doesn't seem like it explains anywhere that after you assemble a program MAC/65 will print the addresses of all the labels it contains, so you are supposed to start executing at the address that is displayed for the routine name. An alternative to this is to always put the main routine at the start of the listing, so there is no ambiguity as to where in memory it will end up. In this particular case, the string could be placed at the end of the listing, right after the RTS opcode and before the .END directive. In the case where the program worked properly is likely because the string was very short, so it only executed a few instructions that didn't make it branch somewhere else in memory nor stomp the string. You could confirm this by stepping through the program in the debugger from the very first instruction, it should execute maybe two or three garbage instructions and then the program counter will match with the first real instruction of the program, so the garbage it executed before is of no consequence.

❤❤❤❤❤😊😊

You could use pop-shell for tiling window for managing multiple window on the same screen. My WM is Gnome and I don't want to use pure tiling WM so I use pop-shell extension on Gnome shell so you have an option for using overlay windows or tiling windows. BTW pop-shell is an opensource project for pop-os .

this is such a cool idea

Love the thumbnail! 😂😂

Hi Ellyse, this series is a lot of fun, thanks for making it! I know the 6502 reasonably well but don't know that much about the Atari computers so I'm looking forward to learning more. I think you mentioned a couple of times not being too sure what the D flag is for. I assume this will be covered by Atari Roots on a later chapter but maybe this can clarify things a bit in the meantime. When the D flag is set, ADC and SBC will interpret values as BCD instead of binary, so a number like $19 is interpreted as 19 decimal, not 25 decimal like it would be when the flag is clear. So if you add 1 to it, for instance, the result will be $20, which is interpreted as 20 decimal, instead of $1A which would be 26 decimal with the flag clear. This is a very convenient representation for quantities that you want to display on the screen, since a byte can now be interpreted as two nibbles ranging from 0 to 9. Displaying numbers is something you will normally do on a videogame for things like score, time, lives, etc, so this representation allows you to do it with the least amount of work. If the 6502 didn't have a decimal arithmetic mode of operation, you would need to convert the number from binary to BCD on your own before displaying it or implement your own decimal arithmetic addition and subtraction routines.

Was this session live ? I missed the notification : (

I didn't want to take up your time while live, so let me clarify my question. I am working on a personal project. Specifically, it is the card game Euchre, which is very popular in my state (Michigan). While programming it in the early stages, and with not a whole lot of programming experience, I ran into a frustrating situation. I enjoy programming the text stuff, but it ends up looking like an 80s choose your own adventure game. This is why I want to have a GUI to just allow people to click a card rather than spelling out "A◆" which could be clicked or typing "pass" which could be clicked using a button. I would rather have a .png or .jpg of the card and allow the user to move the cards in their hand to whatever order they want. I am thinking of using Flask because then I can use HTML and CSS, and I wouldn't be tied to something like Android. I looked at Kotlin and feel it would be better to learn and use Javascript and incorporate it within stuff I am more familiar with. I am not really saying HTML or CSS are "legit" languages, but rather something I can branch off of. One interesting comment you made included C#. Is that significantly different than C++ with what I want to do? I took an intro course where we did some Python and some C++. I found it easier actually to do C++, and then I would recreate the same thing in Python, which is backwards. They say to learn Python, then C++, but the extra syntax helps remember the code like Chinese characters instead of phonetic groups of letters. I can then see what is supposed to be done and remember it.

13:30 Gleam users are called Gleamlins! :)

Thanks for checking out Gleam!!

Thanks for making this video. I like that you spend time using the vocabulary of the programming languages and don't assume people already know it. And since you know some Japanese, すごいですね!!

Yay, another episode! While following along, whenever I do anything with disks, atari gives me random errors. But I reset and redo the same steps and it just works. Resetting seems to be the magical solution to everything here. By the way you asked if we could hear the beeps atari makes on keystrokes, but I couldn't hear it on the video. You might want to check your sound capture setting next time, it will add to the vibe :)