Live data from Hacker News

How I coded in 1985

blog.jgc.org

71–80 of 120 posts

Re: How I coded in 1985

#71
post #27
post #5

That headline got me to thinking... Date: Monday, April 29, 1985 Age: 29 Location: Santa Ana, California. Company: electronics manufacturer setup: dumb black & green 24x80 14" CRT terminal Hardware: Honeywell mini OS: Honeywell proprietary DBMS: Pick (Ultimate Flavor) Language: BASIC App: Work Order Processing (I wrote from scratch.) Date: Monday, April 29, 2013 Age: 57 Location: Miami, Florida Company: aerospace man…

How did I know this story would have your comment and it would be up top? :) To still add something to the discussion -> I never coded on a black&green CRT, but I did learn programming on an environment doing 24x80 16colour ... graphics? Text graphics. (this was ~1994) It was fun. For the first few years of my computing experience I never really left DOS and kept trying to reproduce the shiny Windows stuff in there.…

My story is also similar to yours, but it involves QBasic, Mode 13h, and 1995. :)

Re: How I coded in 1985

#72
post #5

That headline got me to thinking... Date: Monday, April 29, 1985 Age: 29 Location: Santa Ana, California. Company: electronics manufacturer setup: dumb black & green 24x80 14" CRT terminal Hardware: Honeywell mini OS: Honeywell proprietary DBMS: Pick (Ultimate Flavor) Language: BASIC App: Work Order Processing (I wrote from scratch.) Date: Monday, April 29, 2013 Age: 57 Location: Miami, Florida Company: aerospace man…

You're connected right now to a Pick system? From your point of view, how does Pick compare to the current wave of NoSQL databases, practically speaking? What are the advantages and disadvantages?

Re: How I coded in 1985

#73
post #60

As a relatively new (5 or so years experience) programmer, 1985 sounds like hell.

Software development basically peaked in the mid 1980's. Macintosh Common Lisp circa 1987: http://basalgangster.macgui.com/RetroMacComputing/The_Long_V... , specifically: http://basalgangster.macgui.com/RetroMacComputing/The_Long_V... Firebug circa 2013: http://getfirebug.com/logging , specifically http://getfirebug.com/img/logging/consoleDir.png

In the 70s and 80s programmers were working on fixing the problems that programmers faced in the 70s and 80s: memory management, GOTO spaghetti, efficient assembly etc. In response we got heaps, garbage collectors, functional languages, virtual machines, compilers, debuggers, IDEs.

Now most programmers spend most of their time dealing with problems of persistence, networking, parallelism, security, and massive codebases. In response we are creating scripting languages with slightly different syntax, adding closures to Java, and arguing about vim vs emacs. We're so obsessed with solving the problems of the 80s, my way, that we've just gotten trapped there.

Re: How I coded in 1985

#74

This is neat stuff, but it also shows how far behind some schools can be in technology. Yes, I did the hex-keypad-assembler-in-your-head thing, but, by 1985 there were far better options. One word: Forth Funny enough, I built an eleven processor parallel-ish computer in 1985 to control a large (three feet high) walking robot. That's in the days when you couldn't buy kits for this stuff. You had to design all of the m…

My experience so far is that my Forth is shorter, but my assembly has fewer bugs. Maybe this means that Forth wins for larger projects, because it's harder to read but easier to write?

Re: How I coded in 1985

#76
post #5

That headline got me to thinking... Date: Monday, April 29, 1985 Age: 29 Location: Santa Ana, California. Company: electronics manufacturer setup: dumb black & green 24x80 14" CRT terminal Hardware: Honeywell mini OS: Honeywell proprietary DBMS: Pick (Ultimate Flavor) Language: BASIC App: Work Order Processing (I wrote from scratch.) Date: Monday, April 29, 2013 Age: 57 Location: Miami, Florida Company: aerospace man…

Strange how much code I wrote on a 80 char x 20 line Beehive terminal in RSX-11 and later on a 80 x 25 line Heathkit H29 (woo hoo detachable keyboard!). Now with arbitrarily sized screens I really can't go back to just "one" (or in the case of the VT420 "two") screens worth of text.

Re: How I coded in 1985

#77
post #47

Earlier quoted context omitted.

I know that feeling. My undergrad CS course had a rigorous electronics component where we coded in ASM for the 8086. One of my fondest moments of that time was when I wrote a program that would split the terminal screen into two halves of different color, and display what you typed on one side and the inverse case on the other. This could probably be done with less than 50 lines in python, but doing it in assembly, c…

Wasn't it? And for that moment, you could look out and imagine "Damn, I could code the whole freaking thing like this!" Then you realize it would take around 30 years, but still -- it was doable. You finally figured out how it all worked. You could make the computer do anything it was capable of doing . There was no more mystery there. Fun stuff.

Do you really think it would take 30 years? The NAND-To-Tetris kids do most of it in a semester, and they're starting at the level of individual gates.

I mean, Chuck Moore has been doing it for about 30 years, but he had a working top-to-bottom system after less than five years.

Here's what I think it would look like:

Week 0: build a working interactive Forth system that can compile itself, in machine code. This is assuming you already have hardware and a way to boot it into some code you wrote. If not, that could be a matter of minutes or of months.

Weeks 1-3: build an interactive high-level language interpreter on top of it. Say, JS.

Week 4: enough of TCP/IP to do HTTP GET.

Week 5: write a bitmap font editor and a minimal filesystem.

Weeks 6-8: parse HTML (more or less), lay it out with a simplified box model, and draw it to pixels on a canvas, using a pixel font.

Week 9: cookies, HTTP POST, XMLHttpRequest.

Week 10: a more elaborate filesystem, maybe based on Git.

Weeks 11-12: some more HTML5 features, maybe including WebGL.

Weeks 13-14: TLS.

This is sort of cheating because you're taking advantage of our previous 70 years of experience to figure out what's worth building, and you're likely to end up spending a fair bit of time going back and retrofitting stuff onto previous iterations — JIT compilation, say, and multitasking — but it still seems like rebuilding the personal computing environment ought to be more like a one-semester project than a 30-year project.

You could argue that you get a huge speedup by not writing stuff in assembly, and I agree, but I think that's only a constant factor. You could easily write assembly code that maps directly onto JS semantics:

        ;;; invoke getContext("2d") on the canvas object
        .data
    sgetContext: .asciz "getContext"
    s2d: .asciz "2d"
        .text
        mov $sgetContext, %eax
        call GetProp
        mov $s2d, %edx
        call InvokeMethod
That's more code to write and read, but only by a linear factor. So it might take you two semesters, or four, but not 60.

Re: How I coded in 1985

#78
post #47

I remember playing around with machine instructions on the 6502. I wouldn't call it hand assembly; it was more like copying and groping around. I probably wrote less than 200 lines in my life. But what a neat feeling! There's something about putting in these numerical codes and seeing a graphical result that I haven't experienced since then. Yes, higher-level languages rock, but dang, this is coding next to the metal…

I know that feeling. My undergrad CS course had a rigorous electronics component where we coded in ASM for the 8086. One of my fondest moments of that time was when I wrote a program that would split the terminal screen into two halves of different color, and display what you typed on one side and the inverse case on the other. This could probably be done with less than 50 lines in python, but doing it in assembly, c…

I, too, know that feel bro.

At 12 I had learned how to program, in Z80 assembly, a routine to output to the graphics card of my dad's ancient-even-then Radio Shack model 16. I created a custom font that looked like the beautiful VGA font and used it to render 16-bit numbers in gorgeous decimal digits.

Re: How I coded in 1985

#79
post #34
post #17

one of the good things about a formal CS education (well, mine anyhow) is that they force you to do things like write in assembly. obviously there's far less immediate practical application these days, but the exercise is definitely valuable, and probably not something I would have done voluntarily. Actually, it feels like something I would have thought sounded cool, tried, and then given up on when it got annoying.

We had to make adders, flip-flops, etc (on paper, not physically) and those were used to build an ALU and (I think) a memory-switch bank. It was very cool to know that when the world ends I can build a new computer, from scratch.

What are you going to make the logic devices from? I've speculated about this extensively in http://lists.canonical.org/pipermail/kragen-tol/2010-June/00... but I still don't have a working scratch-built computer.

Re: How I coded in 1985

#80
post #72
post #5

That headline got me to thinking... Date: Monday, April 29, 1985 Age: 29 Location: Santa Ana, California. Company: electronics manufacturer setup: dumb black & green 24x80 14" CRT terminal Hardware: Honeywell mini OS: Honeywell proprietary DBMS: Pick (Ultimate Flavor) Language: BASIC App: Work Order Processing (I wrote from scratch.) Date: Monday, April 29, 2013 Age: 57 Location: Miami, Florida Company: aerospace man…

You're connected right now to a Pick system? From your point of view, how does Pick compare to the current wave of NoSQL databases, practically speaking? What are the advantages and disadvantages?

UniData/UniVerse were acquired by IBM and then spun off to form Rocket Software. As I recall (this could be total folklore) the product team wasn't getting the love from IBM and managed to convince IBM to sell off the BU.

Rocket and IBM have done a bit with U2 to open up the multi-value data files and UniBASIC programs to "open systems", i.e., Java, .NET, SOAP, REST-ish, etc.

It's still a bit of a pain because values are strings, one has to extract MV/SV data by tokenizing along delimiters, there's a massive amount of data duplication (no FK relationships), multi-byte causes problems with older programs (and many, many of them are very old programs), and there's no concept of data queues as you might be expecting if you've worked in an OS/400|i Series|System i|i|etc. shop with RPG.

That said, it runs happily on Linux and is quite robust.

Many of the problems relate to programming practice. As you can imagine, there are some "lifers" who don't stretch themselves, argue GOTO vs. GOSUB, copy-and-modify existing programs for new requirements, and don't use source control or automated unit testing. Then there are those who refactor 17 copied versions of programs doing basically the same thing into a modular package and slap an object-ish API on top.

With a rational approach, the environment is actually quite pleasant, but it does take some discipline. It is difficult to retrofit a more rigorous engineering process onto legacy code, but that's the case whether it's Pick/UniData or any other programming environment.

Post reply on HN