Lines 6530 - 6539 are the "MICROSOFT!" that gets printed.
Line 4914 is the code to check the address passed to WAIT and, if correct, print the "MICROSOFT!".
It really is inconspicuous. A source licensee definitely wouldn't find it by quickly perusing.
"".join(map(lambda n: chr((n & 0o77) + 64), reversed([0o241, 0o124, 0o106, 0o217, 0o23, 0o217, 0o122, 0o103, 0o211, 0o315])))
* https://github.com/dspinellis/unix-history-repo
You'll also enjoy the contributors list.
This lead to the phrase “pressure sensitive buttons” being bandied about, which is kind of funny (what is a pressure insensitive button? An immobile lump I guess).
It's just a nice touch.
from Paul Allen's Idea Man biography:
... It gathered steam with the release of the 6502 chip from MOS Technology at an unheard-of $25. For each new microprocessor, I created a new set of development tools on the PDP-10, while Ric [Weiland, 2nd new-hire, 4th employee] helped with the BASIC interpreter rewrites.
So Ric Weiland would have done much of the 6502 BASIC interpreter.
AUTTXT: ACRLF
12 ; ANOTHER LINE FEED.
DT"WRITTEN "
DT"BY WEILAND & GATES"
ACRLF
0> Rick Weiland and I (Bill Gates) wrote the 6502 BASIC.
I put the WAIT command in.
Mark Chamberlin and I wrote the 6800 BASIC.
Now who wrote the 6502 version? The KIM-1 BASIC manual credits Gates, Allen and Davidoff, the original authors of the 8080 version, but it might only be left over from the manual for the 8080 version. Davidoff, who worked for Microsoft in the summers of 1975 and 1977, had not been there when BASIC 6502 was written in the summer of 1976, but he probably changed the 6 digit floating point code into the 9 digit version that is first found in BASIC 6502 1.1 (KIM-1, 1977).
The ROM of the 1977/1978 Ohio Superboard II Model 500/600 (6 digit BASIC 1.0) credits RICHARD W. WEILAND, and the 1977 9 digit KIM-1 BASIC 1.1 as well as the 1981 Atari Microsoft BASIC 2.7 credit “WEILAND & GATES”. Ric Weiland was the second Microsoft employee. These credits, again, were easter eggs: While they were clearly visible when looking at the ROM dump, they were only printed when the user entered “A” when BASIC asked for the memory size.
According to apple2history.org, Marc McDonald (employee number 1) wrote the 6502 version, but it is more likely that McDonald wrote the 6800 simulator and Weiland ported 8080 BASIC to the 6800 and then McDonald adapted the 6800 simulator to the 6502 and Weiland wrote the 6502 BASIC.
This and the hidden credits in version 1.0 of 6502 BASIC suggest that Weiland was the main author of 6502 BASIC. Gates is added to the hidden credits in the 1.1 version, so Gates probably contributed to the 1.1 update..It's doable, but would have to doctored, there was no git then, obviously.
DATE FORMATS
The GIT_AUTHOR_DATE and GIT_COMMITTER_DATE environment variables support the following date formats:
Git internal format
It is <unix-timestamp> <time-zone-offset>, where <unix-timestamp> is the number of seconds since the UNIX epoch.
$ git commit --amend --date='1970-01-01T00:00:00' --reset-author
[main 6e1d001] test
Date: Thu Jan 1 00:00:00 1970 +0000
1 file changed, 1 insertion(+)
TZ=UTC git commit --amend --date='1969-12-31T23:59:59Z' --reset-author
[main 47e54f0] test
Date: Mon Dec 31 23:59:59 2012 +0000
1 file changed, 1 insertion(+)For any ordinary commit you can simply include "--date=" with the 'git commit' command, e.g. -m "This is an old change" --date="2001-03-02 18:05:47"
Seeing him git clone Microsoft BASIC and make the changes atop it was definitely a weird but awesome moment.[2]
[1] https://youtube.com/playlist?list=PLowKtXNTBypFbtuVMUVXNR0z1...
3 years ago I modified his 6502 breadboard project and added a keyboard, display and then I modified MS Basic to get it to run. Also, I found a way to extend the RAM to 31kb. I called it eater-one.
All of his videos and kits are a must if you never understood how a cpu works. I highly recommend them.
Were PDP-10 text editors of the day able to easily work with such large documents? And how long would it typically take to assemble all of that code in one go?
If you were using a KA10 variant, your process could get evicted pretty easily because the core memory requirements of all the running jobs had to be less than 256K words. The variants with paging would have a more efficient method for virtual memory.
Compile times would be affected by the same issues.
# MightyMoose
*.mm.*
Link to the file: https://github.com/microsoft/BASIC-M6502/blob/main/.gitignor...
Regardless, thank you Mr. Hanselman. This is great!
[0] https://continuoustests.com/
[1] https://github.com/github/gitignore/commit/2183a6c531d7085e2...
I don't think that the .gitignore file is meant to reflect anything about when this BASIC interpreter was written, it looks like it's just a MS managed .gitignore that accounts for everything that was ever popular for development in Visual Studio, even things that have been obsolete for decades. In order to handle your most legacy C#, F#, VB.NET, or Visual C++ solutions.
I did a lot of hobby programming in BASIC. But I wonder how many commercial applications were written with it. Did small or big businesses write their own BASIC programs for internal needs?
Though, past a certain point of complexity, performance aside, assembly might be more readable than BASIC because BASIC relied on line numbers for jumping around, whereas assemblers offered named labels.
True that. Who could forget "One moment for house-cleaning!" as it ran a FRE(0) every time you saved.
(... uh, everybody?)
I've written a fully functional emulator for my first love, the Philips P2000T [1], but never released it because I couldn't find a legal way to distribute it. Most software for this machine requires the BASIC ROM, and even reverse engineering it might not be entirely legal.
If anyone knows where to address my requests to Microsoft, I'd be very happy to hear that.
A good start would be for MSFT to also open source the related BASIC-68 and BASIC-69 versions.
> "The extended 8 KB version was then generalized into BASIC-80 (8080/85, Z80), and ported into BASIC-68 (6800), BASIC-69 (6809), and 6502-BASIC." - https://en.wikipedia.org/wiki/Microsoft_BASIC
Anyway, Id start with the Microsoft CEO. Id even email Bill Gates - he would have to"have some sway" if you could get his support - maybe internally ...?
May be the old authors of the software could request it be released. Is it know who the authors of the ROM was? OR Even other hardware designers / workers who worked on original system - would bring interest to Microsoft and have to have some kind of positive momentum to such a request.
Is it possible to work out the reasons how other old Microsoft software was released ? I imagine there would be reluctance to release anything that they thought had commercial value?
As several products have been released over the years - there must be some offical or unoffical process
Legal would have to have input
I imagine there would be some close examination of software to verify , no negatives against Microsoft would / could he harboured in code OR found.
So it would take some resources - maybe several days as a guess - but I really have no idea ... For example probably would want to verify it can be rebuilt - maybe?? would need to setup old toolchains , old hardware etc
Also Some of these software may have been lost - could be embarrassing for Microsoft to admit this.
{Aside - I used to work as a software configuration manager for a larger company - whose job it was to ensure all project code was collect, ensure we capture all the artifacts ( source and deliverables etc ) so it could be reliably independently rebuilt. This included all needed tools etc etc]
Unfortunately, the outlook for most Philips P2000T software is rather bleak, at least from a legal standpoint. The machine enjoyed only limited popularity, and commercial developers showed little interest in supporting it. As a result, much of the available software, particularly games, was written by hobbyists, and sharing through copied tapes was common practice.
In the Netherlands, where the P2000T had its strongest following, copying software was legally permitted until 1990. After that, it became prohibited. Complicating matters further, many original developers released their programs under pseudonyms and provided no contact details. One can obtain quite a lot of this software by buying second-hand machines and tapes. However, redistribution is not legally allowed. As the magnetic tapes gradually degrade, many titles risk being lost forever.
Here's a video of it running: https://www.youtube.com/watch?v=PUa9Ktmsxww
The ROM seems to be available via the usual unofficial sources for MAME-supported ROMS: https://wowroms.com/en/roms/mame/download-philips-p2000t/974...
I'd suggest leveraging the MAME distribution model (distributing emulators separately from copyrighted ROMS). You could also contribute the abandonware software titles you've preserved to the MAME Software-List: https://docs.mamedev.org/contributing/softlist.html. There's no sense in re-inventing the processes and standards the preservation community has already established. Plus once you start the ball rolling, the active community of people trying to preserve cassette-based software from niche 8-bit platforms can join in.
Of course, getting ROM distribution officially blessed by the corporate owner of record would be lovely but it rarely happens because of the legal complexities involved. Obviously, there's zero commercial value anymore but it's still much easier for a corporation to tacitly look the other way than to grant express permission.
[0] https://devblogs.microsoft.com/oldnewthing/author/oldnewthin...
(BBC BASIC is pretty horrid by modern standards, but you'll probably still like it more than Microsoft BASIC. Has arbitary length variable names, multi-dimensional arrays, integer variables, PROCs, FNs, and an inline assembler.)
The book has intro chapters describing the entire design, bugs that snuck in, etc.
While this code dump is cute, and MS basic more widespread (at the time), the overdone readme and the 48 year delay make it a lot less interesting
[1] https://archive.org/details/ataribooks-the-atari-basic-sourc...
https://github.com/microsoft/GW-BASIC
So I think it's likely that more will follow.
I have discussed this with Philips [3] a few years ago, and they were open to sharing it, but I could not find a contact at Microsoft.
[1] https://archive.org/details/20230420_20230420_1351
[2] https://www.retrocomputing.nl/p2000-basic-cartridge/
[3] https://github.com/philips-software
Edit: for reference, the startup screen shows
PHILIPS CASSETTE BASIC
Versie 1.1 NL
14966 bytes vrijI've looked into building my own BASIC implementation and got quite far with that. Unfortunately, most games that were written back then rely on timing that is near impossible to recreate at that level. Emulating cycle exact Z80 behavior and then having the original BASIC routines on top of that is a far easier route.
[1] https://en.wikipedia.org/wiki/Graphical_user_interface_build...
[2] https://www.cloudwisp.com/exploring-visual-basic-1-0-for-ms-...
I do recall the 640 KB barrier being a limitation. I've forgotten the exact details, but, as I recall, the docs implied it shouldn't generally be an issue - but in practice it was. And it'd always be a problem at the most annoying time.
(But it could just have been some large model thing that experienced real mode fiends would instinctively know to avoid? Coming from a 68000 background, for DOS stuff I'd used Borland's huge model or a DOS extender of some kind, to avoid the segmentation one way or another. Maybe that was the problem.)
Despite the occasional problems I had, I always generally liked it, and felt the UIs I created with it looked really rather nice.
Funny that the DOS version came out after the Windows one.
It amuses me that I'm sat here at my desktop right now using the exact same interface in Visual Studio 34 years later to build a WinForms app.
Sounds like competitor For Vermont Views or the previous product Windows for Data and windows for C
No sure of the names ... my recollection this software was in use in early 90s and maybe late 80s
Borland Turbo Pascal and Borland Delphi where also (similar) products from around that time. These products where popular at the time. ( The development system provide include some kind of windows system for the application )
Microsoft even hired key Delphi person ....
Visual Basic 6 rebuilt in C# – complete with form designer and IDE in browser
I like to imagine that there was actually a VB7 in the works with a lot of enhancements to VB6 that we just never got to see once Microsoft dropped .NET and made VB .NET a thing.
The amusing thing about native VB is that Win32 is still, to this day, carrying a bunch of APIs (Var*) that essentially encode its semantics on Variants, e.g.: https://learn.microsoft.com/en-us/windows/win32/api/oleauto/...
(Which itself was designed to a large extent to match what VB was doing before, so it's a bit circular).
And let's not forget that .NET grew out of the "COM 2.0" project. Which started in 1998, at the same time VB6 was released.
Nice to see it out there under the MIT license, certainly. This makes it legal to actually use in many scenarios where it wouldn't be legal to use it previously.
Yawn. Everything “democratizes” everything these days.
Before we got our home computer, the closest I ever got to a computer was reading about them in the encyclopedia.
What Stallman did a decade later was great if you happened to have access to the type of computer that could run Emacs. Even then, you probably didn't own the machine and maybe even had to pay for time on it by the hour. The small machines that ran Microsoft Basic were in people's homes.
No, a decade later was at the end of the 1980's. At that time, many middle class families could afford home computers like the Atari ST, which could run many of the GNU compilers/tools.
It was a great learning experience porting Unix apps and games to the ST.
You might be thinking of basic Motorola 68000 support which GNU C did have in the late 80’s but you couldn’t build a set of GNU tools that ran on the ST with it.
You could have that BASIC experience on a minicomputer like the PDP-8, 11, or 20 which you might have at a high school or college earlier but with microcomputers you could have it in elementary school or at home.
[1] https://thedoteaters.com/?bitstory=bitstory-article-2/breako...
[2] http://blog.hardcoregaming101.net/2012/09/basic-history-of-b...
Like when awaiting pizza delivery, "they're here in 10 mins" doesn't directly relate to a specific guy
Could be wrong though
And no, to answer your question
"7/27/78 FIXED BUG WHERE FOR VARIABLE AT BYTE FF MATCHED RETURN SEARCHING FOR GOSUB ENTRY ON STACK IN FNDFOR CALL BY CHANGING STA FORPNT TO STA FORPNT+1. THIS IS A SERIOUS BUG IN ALL VERSIONS."
Not far off from a comment I might make these days
https://github.com/microsoft/BASIC-M6502/blob/main/m6502.asm...
The quotes below only talk about OS source code, but they found language interpreter source code as well, see register story.
> "So, for a few years that is where I spent my time. I'd skip out on athletics and go down to this computer center. We were moving ahead very rapidly: BASIC, FORTRAN, LISP, PDP-10 machine language, digging out the operating system listings from the trash and studying those. Really not just banging away to find bugs like monkeys[laughs], but actually studying the code to see what was wrong." [4]
> "While his parents were concerned with his slipping grades, there was no slowing him down. He and Bill would go “dumpster diving” in C-Cubed’s garbage to find discarded printouts with source code for the machine’s operating system"
[1] https://en.wikipedia.org/wiki/BASIC-PLUS#Comparison_to_MS_BA...
[2] https://everybasic.info/doku.php/basics/decbasic#influence_f...
[4] https://americanhistory.si.edu/comphist/gates.htm
[3] https://www.theregister.com/2000/06/29/bill_gates_roots/
A lot of us did the same thing in that era. It's surprising how much information can be learned from what others think is useless.
Thank you SUNY New Paltz and the IBM submarine facility (no idea what it was called) for not securing your Dumpsters. It's how I learned computing before it was taught in schools.
Bill Gates played a significant role in jumpstarting the commercial software industry, especially with his "An Open Letter to Hobbyists" in 1976, which urged people to pay for software.
Erum, none of your references show this (or come remotely close).
MS did base NT on DEC work, and settled a court case as a result. Perhaps you're thinking of that story?
BASIC the language pre-dates the DEC implementation (it came from Dartmouth College), and nobody would reasonably think that seeing the code for a high level language BASIC interpreter implementation for Machine A, then writing an assembler implementation for Machine B means you "based it on their work".
The internal structure of DEC BASIC PLUS is a far, far cry from what MS-BASIC (MSB) is. Outside of some shared syntax, the implementations are night and day.
BASIC+ (B+) is compiled to p-code, not tokenized and then interpreted. Those are completely different runtime approaches. B+ has a raw text source that is edited and maintained by the runtime, MSB does not. After you hit ENTER on MSB, your "source code" is gone. It's converted, and not necessarily losslessly, into an internal tokenized form. That tokenized form is read and recreated into the source lines you see when you LIST the program.
This scratch text file for the B+ program actually allows B+ to work in even more memory starved environments than MSB because the text is never fully loaded into RAM, so the bulk of RAM is compiled byte codes and data. You also don't have to "pay" for having extra spaces in your code, as the raw text does not impact that actual runtime size in contrast to MSB tokenized form.
B+, being compiled, supported much different styles of things like loops and if statements.
10 ODDSUM=ODDSUM + A(I) IF A(I) MOD 2 = 0 FOR I = 1 TO 10
On the surface, they look similar with their interactive development environment. Internally, it was a completely different story.
Only if you weren't there.
You won't find the answers to everything online.
DonHopkins on Sept 16, 2018 | parent | prev | next [–]
Speaking of weird BASIC features, does anyone know why DECSYSTEM 20's BASIC had a "LISTREVERSE" command?
Yes, it actually did exactly what it sounds like!
Chalk one up for DEC and BASIC. What other programming languages support that feature, huh?
DECSYSTEM 20 BASIC User's Guide: LISTREVERSE command
LISTREVERSE
LISTNHREVERSE
LISTREVERSE and LISTNHREVERSE print the contents of the
user's memory area in order of descending line numbers.
LISTREVERSE precedes the output with a heading,
LISTNHREVERSE eliminates the heading.
LISTREVERSE
EQUIV 10:53 13-NOV-75
40 END
35 PRINT "THE EQUIVALENT CURRENT IS",I, " AMPERES"
25 I=E1/R
10 INPUT R
5 INPUT E1
READY
I loved the cassette drive and all-in-one chassis. Ah, typing in programs from magazines and creating programs from scratch with PET graphics on the keys! I miss those days. So much wonder and fun.
My next step was Pascal on a VAX at Uni. Never looked back to PET or Microsoft. Linux user today.
The original C64 ROMs (along with AmigaOS) are owned by a company called Cloanto. (Well, I suspect with Amiga OS in particular, it's probably more complicated than that). Not sure if you have to licence MS BASIC separately, or if the favourable deal Jack Tramiel negotiated way back when still covers it.
This split is why the mini C64/A500 units a few years back had actual Commodore software, but didn't have Commodore branding, as they could get a deal with Cloanto, but not the previous owners of the C= logo etc.
Way more complicated in fact, as documented in Amiga Documents[0].
If I wanted to get fancy, I could even use the Amiga side to load and save programs from the A2232's 16K of memory...
normal:
lda #0 ; load accumulator immediate
lda (index),y ; load accumulator indirect,y
ldai 0 ; load accumulator immediate
ldady index ; load accumulator indirect,y(I say "near universal", because Acorn's MASM had a similar syntax. (See, e.g., https://github.com/stardot/AcornDmosBasic/blob/master/src/DB...) I don't remember ever seeing that described as anything other than an oddity.)
And, also, there are probably assemblers smooshed into Forth or Lisp (or implemented with assembler macros for an assembler targeting some completely unrelated CPU) that work in a similar way, because you're limited by the pre-existing syntax rules. But that feels like a separate category
E.g. various register-register transfer combinations have dedicated mnemonics: TXA, TAX, etc.
LDA (index),Y. has index and Y in the argument space, but the A operand is in the mnemonic. The comma doesn't separate operands but is a displacement operator.
In other words, we really want LD A, (index) + y. Or LD A, (index + x).
There were fullscreen editors. You can see one with a 1978 copyright date at about 14:45 in this video: https://www.youtube.com/watch?v=YQNHg1XuFR4
but i'm gonna guess SOS or TECO, if they were running a bog standard PDP-10 OS from DEC
RETURN: BNE GORTS ;NO TERMINATOR=BLOW HIM UP.> CHKVAL: BIT VALTYP ;WILL NOT F UP "VALTYP".
GW-Basic was the IBM PC port. Kind of more consequential no?
[Repping the Dragon 32 still]
Never change, bureaucracy :)
https://github.com/microsoft/BASIC-M6502/issues/5
One was noting the missing LICENSE, another was noting the missing SECURITY.md, and the other one was a policy bot nagging the repo owner to follow a process to exclude the code from the "Microsoft Internal Github" "to protect Microsoft's property"
> 12/1/77 FIXED PROBLEM WHERE PROBLEM WITH VARTXT=LINNUM=BUF-2 CAUSING BUF-1 COMMA TO DISAPPEAR
Microsoft recently closed a 7 year old .NET documentation bug I opened using Copilot. I am not a fan of AI but the submitted fix was far superior to the basically useless message that had been previously present, so net positive. At being ignored for 7 years, it was unlikely to get better from human effort.
I wish code repos had a "contaminated by AI" flag.
Seems hypocritical for a human being to hallucinate a conspiracy theory about LLMs, with no evidence whatsoever.