• Tongle (unregistered)

    Don't forget all the exciting debugging features you can use with Word!

  • MP79 (unregistered)

    I remember writing my first code on a C64 basic prompt, my second on an Acorn basic prompt, my third on a BBC basic prompt, my 4th in notepad for Borland C compiler, my 5th in notepad for Java lessons at university, it was only when I actually needed a large codebase for my final year project that I started using an IDE. Now at work with everything in an IDE, I look back at myself and laugh. Good for training the eye on errors rather than letting the IDE do it for you mind.

  • trololo (unregistered)

    sounds like some failed Microsoft hidden publicity on their new IDE ....

  • Ruddiger (unregistered)

    first, every class was declared in a single file, contravening the extremely common .NET convention.

    Which one was that? I must be doing it wrong :)

  • EuroGuy (unregistered)

    I do know an example of the opposite, a PhD student who wrote his entire dissertation with the Turbo Pascal editor.

    Which sounds more sane than coding in word.

  • ratchet freak (cs)

    TRWTF is that visual studio won't even open .docx without starting word for you, unless you set it to open with the binary editor

  • An innocent abroad (unregistered) in reply to Tongle
    Tongle:
    Don't forget all the exciting debugging features you can use with Word!
    For the logical symmetry missing from all other IDEs, it even has rebugging features! Future work ensurance etc.
  • Jim is the problem here (unregistered)

    Where's the WTF? I write code in Notepad all the time.

    Biff is right. Choice of editor is a personal preference. The code is what really matters, not the tools used to write it.

    What's next? An article about the superiority of fountain pens and the elitist snobs who use them?

  • AnonymousStudent (unregistered) in reply to Jim is the problem here
    1. docx
    2. not checking whether it compiles 3.fonts
    3. highlighting
  • Lito (unregistered) in reply to Jim is the problem here
    Jim is the problem here:
    Where's the WTF? I write code in Notepad all the time.

    Biff is right. Choice of editor is a personal preference. The code is what really matters, not the tools used to write it.

    What's next? An article about the superiority of fountain pens and the elitist snobs who use them?

    This guy's trolling, right?

  • AnonymousStudent (unregistered)

    btw I happen to use vim, so I think had he coded in notepad - there wouldn't be wtf at all

    captcha: IDEo - lol

  • ANON (unregistered) in reply to Jim is the problem here
    Jim is the problem here:
    Where's the WTF? I write code in Notepad all the time.

    Biff is right. Choice of editor is a personal preference. The code is what really matters, not the tools used to write it.

    What's next? An article about the superiority of fountain pens and the elitist snobs who use them?

    As you can read in the article the code didn't work.

  • ANON (unregistered) in reply to AnonymousStudent
    Comment held for moderation.
  • nobody ever suspects the butterfly (unregistered) in reply to ANON
    Comment held for moderation.
  • faoileag (unregistered) in reply to EuroGuy
    EuroGuy:
    I do know an example of the opposite, a PhD student who wrote his entire dissertation with the Turbo Pascal editor.
    Well, it wasn't a dissertation for me, but I once worked on a project where I didn't have access to a word processor or even a typewriter.

    So in order to produce some printed documentation, I wrote a BASIC (this was the early 90s) program on the same machine I used in the project to control a test rig.

    Endless rows like 100 PRINT "blah blah blah...", but since the printer was of course printing in a fixed-width font I managed to produce some ten or so nicely formatted pages of documentation without too much fiddling :-)

    Sounds weird, but you use the tools you have and the result was still far superior to my handwriting ;-)

  • QJo (unregistered)

    Real programmers, of course, program in whatever tools are most appropriate for the application in question.

    I happen to be using Eclipse (with Notepad++ for convenience in certain circumstances), because it just happens to allow reasonably efficient code development. We've all standardised on it in this code shop. It has its advantages.

    Many moons ago I was tasked with transferring our help documentation (which had been written in some in-house document writer software - told you this was a long time ago) onto a web-based solution. We were VAX-based, and had managed to build a just-about usable interface with the Windows-PC-based network used by the non-technical operations team. To this end we had developed a few templates and macros to be able to write html code with reasonable efficiency, and to style it sufficiently neatly as to be able to present it in the same style as the old documents, but in a form you didn't have to process into postsript and print out before you could read. In short, to make the docs available "on-line".

    All went swimmingly until one of my colleagues (older and considerably dafter than me, and that's saying something) only decided that she could edit the damn things using Word. This of course completely destroyed the neat presentation that we had designed, because the html capabilities of Word were considerably substandard and did not support the functionality we had designed. And the real WTF was: even when she had been informed that this was not the best way of maintaining the documentation (she could log onto the VAX like the rest of us, she knew that, she was part of the VAX team by dammit), she insisted on continuing to use Word because it was "convenient". And who cared whether the result was less than readable? She didn't use documentation herself.

  • Peter (unregistered)

    I worked with a experienced engineer, who felt that Word 2.0 was the best way to write CPLD code. He'd write the code in one color, the comments in another and the compiler directives in a third color.

    Of course, the .doc file would not compile as written. First, the text was exported as a .rtf file. Next, he ran a complex script that used the text color as a cue to format the commands correctly. Finally, he ran the resultant source file into the CPLD compiler.

    As our organization had long ago made the transition to XP (under which Word 2.0, not surprisingly, does not run), he kept a special machine loaded with Win95, on which he ran his editing system. As this machine wasn't networked, the source code had to be transferred to the system on which the CPLD compiler ran by USB key.

    I wish I was kidding. I actually saw this and had to work on his code, when he left on a two week summer vacation. There was nothing wrong with his code, the guy was a good engineer. He just had this desire to make everything more intricate and complex than it needed to be. Job enrichment, I guess.

    I ended up exporting his source .doc files as .txt and editing them in either vim or Visual Slickedit, something with an automatic syntax formatter for Verilog. I made some progress on the project. When he returned, he was annoyed. The boss seemed to be willing to let me continue to work on the project. The Word 2.0 afficianado left shortly afterwards, leaving us the legacy of a great tale...

  • Franky (unregistered) in reply to faoileag
    faoileag:
    Endless rows like 100 PRINT "blah blah blah...", but since the printer was of course printing in a fixed-width font I managed to produce some ten or so nicely formatted pages of documentation without too much fiddling :-)
    That does not make any sense at all ... if you can write basic why cant you just write it in a txt-or similar file ... and in case you can't print from that you still can write a loop and go through the lines in basic instead of putting everything in a print-statement directly...
  • ObiWayneKenobi (cs)

    There's really no excuse for typing code in Word unless you are writing an article or paper or something and show code examples. I use minimal text editors for writing quick things when I don't really care about compiling and just want syntax highlighting, but this sounds like Biff is just an idiot. I think something had to have been left out of the story because it reads like he would write code in Word, and then copy it into Visual Studio? That doesn't even make any sense why you would do that, as Word doesn't give you syntax highlighting (to my knowledge) unless you manually go and change the font color of keywords, obviously it has no Intellisense, it won't tell you if your code will actually compile...

    Now I have seen people write sample code in say a Word doc and give to someone as an example of what could be done (although I always find plain ol' .txt to be better) but this reads like he's actually writing code that is supposed to be compiled in Word for some reason.

    Either this lost something in the anonymization process, Biff is totally clueless and a moron to boot, or Jim missed some crucial thing here (maybe the code Biff sent wasn't meant to be used as-is but more an example) but this story as it reads is too far-fetched.

  • faoileag (unregistered) in reply to Jim is the problem here
    Jim is the problem here:
    Where's the WTF? I write code in Notepad all the time.
    Just to show I'm not an IDE nazi: I usually use vim as my editor of choice. But I have worked with Visual Studio and Eclipse, so I know a bit about modern IDEs.
    Jim is the problem here:
    Choice of editor is a personal preference. The code is what really matters, not the tools used to write it.
    That has been true, and, to a degree, still is true.

    However in this case Biff is the WTF and a big one.

    1. I don't know one developer who complains about fixed-width-fonts in an editor. It usually is the other way round but anyway, if I remember correctly, you can set the font in Visual Studio to anything you want. No need to use Word if all you want is TrueType.

    2. Productivity is much improved if you use a modern IDE. Compiling at the click of a button, method lists, refactoring tools etc etc. Not to use Visual Studio in a .NET shop meaning you have to do all the things like creating a solution, compiling etc on foot is such a waste of resources (i.e. time), any decent head of department would probably had a chat with Biff long ago.

    3. If you want licence to do whatever you want because you claim guru status, you should be. And obviously Biff wasn't, since his code was "loaded as it was with misspelled identifiers, missing semicolons, and AWOL closing braces". This refers back to point 2) since now Jim can clean up after Biff and Biff is probably not getting Jim's wages deducted from his own.

    So all in all I would have to conclude that Biff is the WTF in this story.

    And now back to vim.

  • skotl (cs) in reply to Franky
    Franky:
    faoileag:
    Endless rows like 100 PRINT "blah blah blah...", but since the printer was of course printing in a fixed-width font I managed to produce some ten or so nicely formatted pages of documentation without too much fiddling :-)
    That does not make any sense at all ... if you can write basic why cant you just write it in a txt-or similar file ... and in case you can't print from that you still can write a loop and go through the lines in basic instead of putting everything in a print-statement directly...

    It's possible (tho unlikely in the early 90s - 80s possibly?) that the machine did not have any kind of text editor and that, like a C64 or BBC Micro, the only way to iteratively generate anything was to write a BASIC prog via the inline editor / command prompt.

  • Sir Twist (cs) in reply to Franky
    Franky:
    That does not make any sense at all ... if you can write basic why cant you just write it in a txt-or similar file ...
    Because some computers booted directly into the BASIC interpreter and had no way to edit a plain text file.

    Also, get off my lawn.

  • faoileag (unregistered) in reply to Franky
    Franky:
    faoileag:
    Endless rows like 100 PRINT "blah blah blah...", but since the printer was of course printing in a fixed-width font I managed to produce some ten or so nicely formatted pages of documentation without too much fiddling :-)
    That does not make any sense at all ... if you can write basic why cant you just write it in a txt-or similar file ... and in case you can't print from that you still can write a loop and go through the lines in basic instead of putting everything in a print-statement directly...
    And with what editor would I create the file?

    That machine was like a home computer of the 80s. It booted into a BASIC shell and that was basically that. No fancy editor, the only software on the machine being its ROM and the BASIC program currently in memory. Which you could write to disk. Which, of course I did. But even on disk it was a still BASIC program.

  • faoileag (unregistered) in reply to skotl
    skotl:
    It's possible (tho unlikely in the early 90s - 80s possibly?) that the machine did not have any kind of text editor and that, like a C64 or BBC Micro, the only way to iteratively generate anything was to write a BASIC prog via the inline editor / command prompt.
    Yup. The machine, although intended for industrial purposes, much resembled the home computers of the 80s (I had a Color Genie at the time). Those old process control machines were still around at the time as they did their job without much fuss and were easy enough to program.
  • Roby McAndrew (cs)

    I think the clue is the lack of source control. Who needs it when Word has revision control built in? The version history travels with the document !

    (Ducks)

  • Pete (unregistered)

    Nowadays, I prefer glorified plaintext editors (sublime text or notepad++) over full IDE's such as visual studio, eclipse, etc.

    With macros/plugins all of them support the needed functionality anyway (as does vim or emacs); but it feels more productive for me, and less constrained towards a specific toolkit/language/approach as the IDEs.

  • jswright (cs) in reply to Ruddiger
    Ruddiger:
    >> first, every class was declared in a single file, contravening the extremely common .NET convention.

    Which one was that? I must be doing it wrong :)

    It means that every single class is saved within one file. The convention in question states that each class should be saved within its own respective .cs file, although there is a handful of exceptions...

  • Herwig (unregistered) in reply to AnonymousStudent
    AnonymousStudent:
    btw I happen to use vim, so I think had he coded in notepad - there wouldn't be wtf at all
    vim provides :syntax on
  • Julia (cs)

    I once had a client call to tell me their website was down. Basic checks revealed that there was an error happening on every page-load, but without access to the server and the client insisting that nothing had changed since installation, no way to go forward. This was local government at it worst, so it took seven weeks of form-filling, waiting for critical people who were off sick to return, etc. etc. to actually get permission and credentials to vpn in and take a look, by which time the client had already tried to have me formally dinged for breaking the SLAs.

    No web.config

    Instead, web.config.docx

  • QJo (unregistered) in reply to ObiWayneKenobi
    ObiWayneKenobi:
    There's really no excuse for typing code in Word unless you are writing an article or paper or something and show code examples. I use minimal text editors for writing quick things when I don't really care about compiling and just want syntax highlighting, but this sounds like Biff is just an idiot. I think something had to have been left out of the story because it reads like he would write code in Word, and then copy it into Visual Studio? That doesn't even make any sense why you would do that, as Word doesn't give you syntax highlighting (to my knowledge) unless you manually go and change the font color of keywords, obviously it has no Intellisense, it won't tell you if your code will actually compile...

    Now I have seen people write sample code in say a Word doc and give to someone as an example of what could be done (although I always find plain ol' .txt to be better) but this reads like he's actually writing code that is supposed to be compiled in Word for some reason.

    Either this lost something in the anonymization process, Biff is totally clueless and a moron to boot, or Jim missed some crucial thing here (maybe the code Biff sent wasn't meant to be used as-is but more an example) but this story as it reads is too far-fetched.

    "There's really no excuse for typing code in Word ..." Stop right there.

    Dead right. $\LaTeX$ is far superior (if you ignore its colossal disk space footprint).

  • fa2k (unregistered)
    Comment held for moderation.
  • devjoe (cs) in reply to Peter
    Peter:
    I worked with a experienced engineer, who felt that Word 2.0 was the best way to write CPLD code. He'd write the code in one color, the comments in another and the compiler directives in a third color.

    Of course, the .doc file would not compile as written. First, the text was exported as a .rtf file. Next, he ran a complex script that used the text color as a cue to format the commands correctly. Finally, he ran the resultant source file into the CPLD compiler.

    This reminds me of a help authoring tool (let's call it DUH) circa 1999. This was a Word add-on which allowed you to write documents which could be compiled into Windows Help and which could also be used to produce print documents from the same source. Now admittedly, this was actually a document and not a program, so doing it in Word was not TRWTF.

    The source document was a Word document formatted mostly like the intended print output, though certain formatting features were reserved for special meanings in help. (Keep with next, I think, marked a paragraph as belonging in the non-scrolling region at the top of the help topic typically occupied by a heading. Conveniently, headings typically had that formatting option. But this particular WTF is properly credited to Microsoft, as their Windows Help compiler, which operated on an RTF file, used the equivalent feature in RTF for this meaning.)

    TRWTF was that when you wanted to build the help, an incredibly long set of Word macros used information in the document and in text configuration files to insert a bunch of footnote marks that the help compiler used to store metadata about the topics, such as their actual titles (which could be different than the headings, but Doc-to-Help made them the same unless you had multiple identical headings in your document) and index entries.

    Or maybe TRWTF (at least, the one that reminded me of this) was in the way that DUH used colors to indicate sections for print-only (red, I believe) or help-only (magenta). Another part of that long chain of macros removed all the print-only text and changed all the help-only text to black. A new version came out during this period that added support for HTML Help and other output formats; this assigned meanings to a bunch of other colors, allowing you to mark text as belonging only to one specific help output, in case you were building all these different help outputs from the same source for some weird reason.

    And one of my predecessors had constructed this enormous manual/help file which had some very large tables which were deemed reference material and not needed in the help output. So there were pages and pages of red tables that got deleted from the temporary copy each time help was built. This went on for a while (with multiple-hour help builds spending most of their time deleting these tables, one cell at a time). There were lots of other help projects that didn't have massive amounts of print-only material and their help builds ran in a reasonable time; it was only this one project that I'd start when I went out to lunch or at the end of the day and pray it ran successfully.

    Only when Word started crashing did I try to do something about it. It seemed that Word maintained undo information in one of those temporary files that get created whenever you open a Word document. Normally, Word would periodically flush out old undo information and keep this file from growing too large. But while a macro was running, unless you did something to give Word control for a moment, like saving the file, Word never did this. When these tables grew too large, the undo file reached the maximum file size limit on whatever ancient version of Windows we were using, and Word crashed.

    The temporary solution was to split this section up across multiple files. This forced a save in the middle which flushed the undo file.

    The intermediate solution was when I discovered DUH provided hooks within their build process where I could insert my own macros. I wrote a macro which checked to see if an entire table was red, and if so, delete it. And it didn't work, because when you have too big a selection (in this case, more than about 50 table cells was too big), Word's object model wouldn't tell you its color, instead returning the code that indicates the selection has multiple colors. So I rewrote it to check the color of every row, and if all rows were red, then delete the entire table. This reduced the runtime of the print-only-deletion code by about 90%.

    The ultimate solution, when we merged with another group that was using another help authoring tool, was to not defend this tool at all and accept whatever the other group was using, which at the time did not support conditional text, so we had to abandon some of this and either maintain parallel copies or just write things in such a way that they worked in both print and help.

  • Matt (unregistered) in reply to faoileag

    I had a similar, although stupider, issue - on my first computer, a 486 (I was about 12-13ish), I didn't know what a word processor was or where I would get one. The first text-editing program I found was the system's BASIC editor. So I wrote several school papers in that before my parents finally picked up word perfect.

  • Jim the Tool (unregistered) in reply to Roby McAndrew
    Roby McAndrew:
    I think the clue is the lack of source control. Who needs it when Word has revision control built in? The version history travels with the document !

    (Ducks)

    The real WTF is that source control wasn't mentioned in the interview. When you are asked, "do you have any questions", one of the questions you should ask is, "what version control system do you use?". This lets you judge two things straight away: 1) if they have version control at all (and if they don't, it's a negative sign which may contribute to a "no thanks" to any job offer); 2) whether they are stuck in the 1990s and don't use a distributed version control system (like bzr or hg).

  • anotherusername (cs) in reply to fa2k
    fa2k:
    There are some good arguments for using proportional fonts: they are easier to read, though I still use a monospace font myself

    http://developers.slashdot.org/story/10/01/17/0715219/Programming-With-Proportional-Fonts [original blog post is gone]

    http://web.archive.org/web/20110211071525/http://m-mz.posterous.com/programming-with-proportionalUnrelated text so that Akismet doesn't think this comment is spam

  • faoileag (unregistered) in reply to Jim the Tool
    Jim the Tool:
    The real WTF is that source control wasn't mentioned in the interview.
    the article said:
    Jim hadn't heard mention of source control since his job interview
    That sentence would imply that source control had been mentioned in the interview.

    Not that it matters much - I have learned to take things said in job interviews with a grain of salt.

    My favorite is: "Except the gui we do everything inhouse".

    "inhouse" on that occasion meant: at any one of a handful of sister companies scattered around the country.

  • Chris Angelico (unregistered) in reply to Pete
    Pete:
    Nowadays, I prefer glorified plaintext editors (sublime text or notepad++) over full IDE's such as visual studio, eclipse, etc.

    With macros/plugins all of them support the needed functionality anyway (as does vim or emacs); but it feels more productive for me, and less constrained towards a specific toolkit/language/approach as the IDEs.

    Ditto. My setup is "editor with one-key invocation of make, and keep the makefile up in one of the tabs". Currently that editor is SciTE, but that could be switched out for any of a large number of editors.

    Oh, and 42 terminal windows or so. To me, a GUI is a system for laying out terminals so I can find the one I want...

  • JAPH (unregistered)

    Did Dan want to feel superior by referencing the Capgras Delusion? The Capgras Delusion is the belief that someone has been replaced by a double. It has nothing to the feelings "Jim" was experiencing; even the phrase "Jim couldn't help feeling like a bit of an impostor" is too weak for Capgras.

    Oh, like everyone else, I can't imagine a modern programmer using Word to code (and saving the code in a non-text format). To be fair, docx is an xml derived format, and Biff may have been typing on a wooden table.

  • Mike (unregistered)

    A good WTF

    And in a similar vein (and this is sad) kids at school (GCSE) are "learning" html and css by using Dreamweaver.

    Guess what, none of them have even seen the html!

  • operagost (cs) in reply to faoileag
    faoileag:
    skotl:
    It's possible (tho unlikely in the early 90s - 80s possibly?) that the machine did not have any kind of text editor and that, like a C64 or BBC Micro, the only way to iteratively generate anything was to write a BASIC prog via the inline editor / command prompt.
    Yup. The machine, although intended for industrial purposes, much resembled the home computers of the 80s (I had a Color Genie at the time). Those old process control machines were still around at the time as they did their job without much fuss and were easy enough to program.
    You could have written a BASIC program to INPUT lines and write them out to a data file on disk, then read it all back off the disk and send it to the printer line by line. However, you've basically just coded your own primitive editor and it would take a lot more time than just hard-coding a bunch of PRINT# commands. Wow, I can't believe I remember the PRINT# command.
  • operagost (cs) in reply to Matt
    Matt:
    I had a similar, although stupider, issue - on my first computer, a 486 (I was about 12-13ish), I didn't know what a word processor was or where I would get one. The first text-editing program I found was the system's BASIC editor. So I wrote several school papers in that before my parents finally picked up word perfect.
    The QBASIC editor was actually the same program as EDIT with the programming-specific commands. When you ran EDIT, it actually kicked off the QBASIC program with the /EDIT qualifier. Frankly, although it had almost no features, you could probably do a better job with that than some of the cheap word processors (i.e., not $500 like WP5) back then because at least it was bug-free. I had a Cosmi word processor (Cosmi was a company that made software to fill the bargain bins at Wal-Mart and CompUSA) that would truncate the last two characters of every line when you saved the file, so you had to type two spaces before hitting ENTER and couldn't let it do a soft carriage return. How that escaped QA I have no idea. I pirated WP5 from the computer lab when I started college.
  • Chelloveck (unregistered) in reply to operagost
    operagost:
    You could have written a BASIC program to INPUT lines and write them out to a data file on disk, then read it all back off the disk and send it to the printer line by line. However, you've basically just coded your own primitive editor and it would take a lot more time than just hard-coding a bunch of PRINT# commands. Wow, I can't believe I remember the PRINT# command.

    I actually did that. Sherman, set the wayback machine for 1982... I was in high school, and had just spent all my money on a shiny new Apple //e. I had no money left over for software, but I had a paper due and wanted to use my shiny new toy. So one of my very first programs ever was a cheap-ass "word processor". It was a loop around an input statement, appending anything I typed to a single string variable. It did actually have the ability to backspace and delete characters, but it had no other cursor control. I don't even remember if it saved to disk. I do remember that it got progressively slower the more text was entered, and after a page or so it was just plain agonizing. But hey, I got an A on the paper! And continued using the program throughout the semester.

  • HiddenWindshield (unregistered) in reply to JAPH
    JAPH:
    Did Dan want to feel superior by referencing the Capgras Delusion?

    Almost certainly.

    JAPH:
    The Capgras Delusion is the belief that someone has been replaced by a double. It has nothing to the feelings "Jim" was experiencing; even the phrase "Jim couldn't help feeling like a bit of an impostor" is too weak for Capgras.

    I think he was shooting for the "Dunning-Kruger effect" and missed.

  • DCRoss (cs) in reply to ratchet freak
    ratchet freak:
    TRWTF is that visual studio won't even open .docx without starting word for you, unless you set it to open with the binary editor
    Judging by the quality of Biff's code it had never even been in the same room as a compiler, let alone been opened in Visual Studio.
  • ubersoldat (cs)

    If they were using a SCV it wouldn't work with Word documents.

  • gnasher729 (unregistered) in reply to ANON
    ANON:
    As you can read in the article the code didn't work.
    But Word didn't report any errors, so the code was fine.
  • Andrew (unregistered) in reply to Mike
    Mike:
    A good WTF

    And in a similar vein (and this is sad) kids at school (GCSE) are "learning" html and css by using Dreamweaver.

    Guess what, none of them have even seen the html!

    That's not a WTF of the IDE, that's a WTF of the curriculum. Dream weaver is fine for editing HTML or CSS in code or split view. I realize that it has all sorts of wysiwyg nonesense in it as well but you can write pretty much any code in it with varying degrees of syntax hilighting and code completion; ie: C#, PHP, vbscript, ruby, sass, JavaScript, etc... It's not as feature complete as VIsual Studio but for teaching kids HTML and CSS, it should be fine, providing they are writing the code.

  • anonymous (unregistered) in reply to gnasher729
    gnasher729:
    ANON:
    As you can read in the article the code didn't work.
    But Word didn't report any errors, so the code was fine.
    Perhaps he had a mathematical proof that the code was correct.
  • Yazeran (unregistered) in reply to Chris Angelico
    Chris Angelico:
    Oh, and 42 terminal windows or so. To me, a GUI is a system for laying out terminals so I can find the one I want...

    Yep I have it exactly similar, nice to know I'm not alone....

    Yazeran

    Plan: To go to Mars one day with a hammer

  • vali1005 (unregistered) in reply to faoileag
    faoileag:
    And with what editor would I create the file?

    That machine was like a home computer of the 80s. It booted into a BASIC shell and that was basically that. No fancy editor, the only software on the machine being its ROM and the BASIC program currently in memory. Which you could write to disk. Which, of course I did. But even on disk it was a still BASIC program.

    You could have earned some more "historical" points by saying "Which you could write to tape" :) :) :)

    Got my start on ZX Spectrum and HC-85(Romanian clone of the ZX Spectrum) :)

    CAPTCHA: tation; "It's a tation, not a citation!!!"

Leave a comment on “An IDE Impostor”

Log In or post as a guest

Replying to comment #:

« Return to Article