JCS's post on Irreal today brought me back. It was about Brief which was the editing hotness back in the day. I played with it a little really mostly used Emacs clones for real work when I was stuck on MS-DOS systems. Usually either JOVE or Epsilon
In the comments Jon reminded me about the MKS Toolkit which brought most everyday Unix tools to DOS along with a shell and a version of Vi. I didn't use Vi much and I only used their shell until I wrote my own.
This got me thinking about "rite of passage" projects. I was in college in the mid to late 80s. It was the heyday of the IBM-PC. Schools still used older time sharing systems like DEC-20s and Vaxen but the PC was all the rage. The cool thing about them was that you had full control and access to the machine and it was simple enough to get your head around pretty much everything about it. The downside was that MS-DOS was very limited and of course there was little to no networking going on.
On the one hand, you could dive into the low level machine language stuff very easily. Get Norton's book:
and you're on your way.
On the other hand many student's graduated with no concept of time sharing and the ramifications of sharing a system or resources were foreign to many kids.
Even though we always look back to the "good old days," in many ways things weren't much different. I got a very strong background in academic CS from NYU (Courant Institute) but just like today, there was no real preparation for the real world.If you wanted to really develop your coding chops you had to work on side projects.
I seem to recall, a typical "rite of passage" side project was writing your own shell. It didn't have to be anything as powerful as BASH or ZSH but it would typically be much more powerful than DOS and much more Unixy.
I recall writing my first shell down in UC-49 of Tisch Hall when the computer labs weren't busy. I wrote it in C which was what the cool kids used back then. Specifically I used the Let's C compiler from the Mark Williams company. This was before Turbo C 2.0 so Let's C was pretty much the only game in town for a cheap Unix style C compiler for DOS. There was also Run/C but that was a C interpreter, not a compiler. I also used that to learn C. Funny story - I certainly didn't know this at the time but Run/C was written by Peter Brooks. Peter and I would later meet when he became my colleague at Stuyvesant teaching CS and I now have the privilege of being able to call him friend. I joke that I owe him ~ $100 for the interpreter from back in the day.
Since this was on DOS, I couldn't do real Unix style pipes like ~cat file | sort | uniq -c | sort -n~ but I did simulate it with redirection and temporary files. It also supported aliases, simple scripts and I think a few other things.
I was pretty happy with it and used it for a couple of years. It was also one of the first substantial programs I wrote. I learned a lot from doing it.
Another "rite of passage" program that was common back then was a text based window library. Somethig like ncurses that would allow you to make text based windows and menus on the text only screen. I also wrote one of these and actually got to use it for a project when I started working at Goldman.
I guess the third "rite of passage" project I remember was writing a C compiler but that was different because it was for a class. It was a significant project but the class didn't really help with writing a large program in general - it was all about the compiler and all the theory behind it. Great course but not one in software engineering.
Nowadays the projects have changed. Text based windowing is long gone and while I still think writing a shell is a useful and rewarding exercise it's not scratching an itch the way it did back when we were stuck on DOS. I guess writing a full stack web app is probably a pretty typical one for students these days.