It’s a real statistical outlier, nearly every language people have moved on from gets negative reviews. Me, it was fun but it wasn’t for me and eventually I concluded a number of the fundamental design decisions were wrong.
Here’s one: Mike Rettig wrote a great post about this in the early days, long since lost to time. Didn’t take that much note of it at the time but grew increasingly convinced over time: shared memory primitives are a bad idea. We would have been better off with an architecture that prioritised message passing. (Not that you can’t do message passing in Clojure, just that it isn’t privileged the way STM is.)
These days, it’s mostly C#. It’s got one of the most sophisticated list processing modules of any language I know of, you can fairly easily write heavily immutable code. It’s a bit niche because Microsoft but it’s nonetheless solid.
My downsides compared to Clojure: no destructuring in parameter declaration. No immutable by default.
But it turns out I prefer typed languages. Which isn’t a thing I’m going to argue about!
Less ex-user, more like: never really managed to get to use it at work I guess (just like it is for me). It is still a niche language (compared to the big ones) after all.
When it comes to PL implementations, there are lesser materials about creating relevant tools besides compilers: linkers and especially debuggers. Are there any coursers/books that go into implementing these tools?
Since we had to shift (i.e. copy) blocks of data around in order to dynamically resize partitions that were formatted with FAT, NTFS, or HPFS file systems; we had to know the internal structures of each of them.
It's been a long time, but I seem to remember that there were a few areas that were not documented well by Microsoft and we had to guess what certain fields meant.
Because we often had to move file contents around, some files became more fragmented while others became less fragmented since we tried to be smart about where we moved file blocks.
My biggest takeaway was understanding file system architecture. For some features, I was impressed by what their architects designed. For others, I wondered why on Earth they did it 'that way'. I started keeping a list of things I wanted to be different and eventually incorporated many of them in my new object store design.
Our UI guy (a good friend of mine from college) did a really good job of making our DOS app look like a windows app.
The first version of our disk imaging product (Drive Image) was not so polished because I was the only one working on both the engine code and the UI layer. Once that started selling we'll, they assigned someone to help me with later versions.
reply