>>5Yes I extend my complaint (although not quite your understanding of it, but it is close enough) to C and all ``minimal'' and ``elegant'' languages that mature or branch of into something very ugly (C11, Objective C, C++) when (very intelligent (Stroustrup), but not very wise (Alexandrescu, Stroustrup)) users realize they can't write large systems very well in these ``minimal'' and ``elegant'' languages (some of them, are still in denial, and are thus still ``elegant'' and ``minimal'' e.g. Go)
You mention Lisp. I love Lisp. Pertinently, a great Lisper once wrote:
it is often said that small is beautiful. now, anything can be beautiful when it is small. the ugliest person you can think of was probably a quite pretty baby. it doesn't take much effort to find a beautiful 16-year-old girl, either. in fact, our modern notions of beauty and elegance are _defined_ in terms of size and maturity, so the chance of anything small and immature being beautiful is vastly higher than anything big or mature. Now, despite all the marketing that seems to be aimed at telling me that I should dump a girlfriend when she becomes 25 and get a new 16-year-old (or even younger), I plan to stay with mine partly because of her ability to grow older in a way I like. consequently, I take exceptions to the pedophilic attitudes to beauty and elegance that our societies have adopted over the years. this is why I don't like the "small is beautiful" model of aesthetics. this is why I think that almost anybody could make something small and beautiful, but only a few can create something that grows from small to huge and still remains beautiful.
I do not have much love for Java, but now that I am faced with maybe writing in
ENTERPRISE SEPPLES again (after writing a bunch of Smalltalk and Common Lisp), I wish it was Java. Java has a little bit of the essence of Lisp in it (indeed the language specification cites Smalltalk (Lisp's cousin) and CLOS and the Great Quux himself (infamously) wrote ``We were not out to win over the Lisp programmers; we were after the C++ programmers. We managed to drag a lot of them about halfway to Lisp. Aren't you happy?'')
I remember when I first learned programming at university (I elected to take a COMP rather than ISYS unit as part of my degree in economics) and it was Java. I wrote some arcade game clones, a raycaster, all these wonderful things, I had the kind of fun someone new to programming has. Everything was magical and beautiful. Anyway I wrote this texture mapper and I couldn't get real time performance, and being a novice I blamed my tools, specifically Java (I was upset at how many layers there were between me and the framebuffer memory). Then I wanted to get ``closer to the metal'' and all these people on Gamedev.net were using Sepples, and all my favorite programs were written in Sepples, and everyone who hated Sepples seemed to hate it because it was too difficult, but that was no obstacle for me. So I learned Sepples and was proud of it. Moreover, I became a
modern Sepples programmer, complete with
BOOST WIZARDRY. I got a job and evolved into an
ENTERPRISE SEPPLES DEVELOPER.
I kept the job and changed majors, and was introduced to just plain C through classes on networks and operating systems. I loved plain C. I loved it's elegance and simplicity. I loved it so much that I re-wrote part of my project at work in C (which took a month). This experience taught me something; and that was to never attempt something so stupid again. I re-wrote it in Sepples shortly after.
Now my attitude then was to lay landmines for anyone going to use my programs incorrectly. I really liked to model my data and be const correct and statically assert all sorts of everything. I was rigorous. No one would dare use my functions incorrectly. Moreover, I wrote in ``functional style'' (you see I was introduced to Haskell at university, and I loved it very much too) I didn't have classes, I had methodless structs, I had namespaces and functions. I was really into concurrency and GPU stuff too. I taught myself OpenCL, I learned the (then boost) threading library, I understood my compilers memory model. And whenever, I'd see someone bagging Sepples I'd think ``prfft amateurs''.
But then I came across a problem which wasn't so easy to solve. Something not numerical, but symbolic. I solved it using a CAS (I introduced myself to CASes just so love this problem, a love that lasts to this day), and I needed that power at run time. So I looked up symbolic computation and found this book called ``Introduction to symbolic computation'' using Common Lisp which seemd like it would put me on the right track. I read on the net about the Lisps and I thought Common Lisp was the worst of them, CLOS sounded disgusting. I hated the word object, I hated object oriented programming after all I was a
modern Sepples programmer with my second tongue being Haskell, everyone knew object oriented programming was some gay thing old people did, and what was cool was being
functional. So I stumbled around with Scheme and Clojure which were elegant, minimal and
functional and not old and gay like Common Lisp. However, I eventually learned Common Lisp. The rest is, as they say, ``history''.
So what happened to Sepples? Well remember how I learned it cause I wanted to get close to the metal? What a joke. What a lie! I can't mmap video memory any easier in Sepples and C than I could in Java (mainly thanks to the kind of terrible operating systems and computer( system)s which dominate the market today). There's nothing ``low level'' about Sepples. There's machine language, and there's everything else. Sepples falls into the everything else category. It's just shitty everything else. The most you can say is that Sepples (or more appropriately C) has a more natural mapping to a register based Von Neumann machine (pointers, fixed width integers, jumpy control flow) than other languages (so there's less hidden costs) but otherwise it's all the same. Change the ISA to something quite different and there's
nothing low level about C anymore.
Moreover, I find it much much easier to write low level programs in Common Lisp than I ever did in C or Sepples ``What I like about Lisp is that you can feel the bits between your toes''.
I never thought I'd be one of those people with an axe to grind against Sepples, my former love, and you know till maybe three weeks ago I didn't. I'd say ``yeah Sepples is no Lisp but we had our fun''. But now, do I really want to be fucking around with Sepples bullshit again? idk. I wish I had 6 years experience in Java instead.