On Thursday, June 16, 2011 10:58:33 AM Phillip Gawlowski wrote:
> "He is obsessed by the minutiae of syntax and apparently uninterested
> in actually writing programs - he needs to invent some `perfect'
> language before he can do anything, and he's starting with the syntax.
> It seems quite likely that he's just trying to avoid doing anything at
> all by endlessly fiddling with syntax."
> 
> Now *that* sounds familiar, doesn't it?

Indeed it does, and this is probably why I respond to him as much as I do, 
because I started out the same way.

This is going to be a long one. I'll try not to tell this story more than 
once, because it's so long, and borders on actually being offtopic.



I wanted a language which was "fast enough", where "fast enough" meant "at 
least as fast as Java, and better if it can approach C++", which compiled to 
portable bytecode, preferrably bytecode for VMs people are likely to have 
(Java or .NET) but a new VM would be acceptable, could run in 32-bit or 64-bit 
modes, had flexible syntax with minimal verbosity, was extremely dynamic 
semantically but ran as fast as static code, handled unicode well, had good 
multiprocessing primitives (like Erlang)...

The list goes on. And on. And on.

I rejected Ruby at first because it was "too slow", and because I didn't see a 
way it could be much faster, especially because I didn't quite understand the 
difference between symbols and strings. Also, it runs from source, and didn't 
seem to have any good compilers -- at the time, I thought I wanted to do game 
development, and while I wanted my game to be almost automatically portable 
(compile once, run anywhere, so I don't have to convince anyone to let me make 
a Linux version), I also didn't want to actually ship source.

While I suppose I had a good rationale for almost every question I asked, I 
followed a very similar pattern to Ilias. I'd get annoyed when people would 
answer my real question instead of the one I asked, because then we'd be 
arguing about architecture, not realizing how much I had to learn about that. 
I would also wander from group to group -- I'm not sure I ever made an 
appearance on Ruby-Talk directly, but I suspect I hit the IRC channel at some 
point. I was really excited about Perl6 before it really was anything 
resembling an actual language. I tried Squeak, and rejected it because 64-bit 
support was experimental, and it seemed that it might be difficult to port 
software between 32-bit and 64-bit, and even if it would work perfectly 
eventually, the amount of work it was taking them to make a 64-bit Squeak VM 
suggested that either the language was too difficult to port or the community 
was too small to react to these kinds of changes in technology.

Basically, I spent my teenage years like this. I would often be tempted to 
reinvent various wheels, and I still am.

But when it came down to it, when I really had to, I could program. It started 
off really sloppy, and I actually still occasionally support programs I wrote 
as a teenager. Still, I was able to get things done, at first mostly in Perl, 
just little things, avoiding any project big enough that it would warrant The 
Perfect Language.

The turning point was probably my first programming job, at a startup. For the 
first time, I was forced to work with other people, and to actually program 
roughly 8 hours a day, every day. For the first six months or so, it was 
entirely JavaScript, running on HD-DVDs. For the next six months or so, it was 
mostly Ruby -- Blu-Ray won, but we took our Rails backend for the HD-DVD stuff 
and adapted it into a music widget.

The second time through, I saw a lot more of Ruby's brilliance. Plus, the 
performance had improved significantly, to the point where it was still common 
knowledge that "Ruby is Slow", but I could no longer see any major design 
decisions which made Ruby _pointlessly_ slow -- any decisions that would tend 
to make implementations slow weren't just carelessness, they were deliberate 
tradeoffs between performance and programmer productivity.

I had to learn, the hard way, that there is no "perfect" language. While I can 
think of some things I wish some language did that no languages do yet, I no 
longer believe that there could ever be a language which is semantically 
"better" than all other languages in all ways. One thing many people on this 
list will be familiar with is Ruby vs JavaScript -- and I have to say, there 
are tons of things I miss about each in the other, and some of them are 
mutually exclusive. I like that every interaction with an object in Ruby is 
actually sending it a message (a method call, usually), but that's 
incompatible with JavaScript's idea that objects are just hashes of methods 
and values.

That, and I actually learned to program.

The biggest change in my thinking now is that, when I was a teenager asking 
the kind of questions Ilias does, I wasn't speaking from experience where a 
given construct actually bothered me. It just bothered me from some idealistic 
standpoint which had no connection to any program I have ever or will ever 
write. These days, when I complain that (for example) autoload didn't actually 
call the system require, I actually do have a good reason for wanting to 
intercept the behavior of autoload.

That is, I've gone from being an idealistic, dogmatic, theoretical programmer 
to being an actual, practicing, empirical programmer. It just took me five or 
ten years, and I probably made some enemies along the way.



So as rude and arrogant as he is, and as little as he deserves (or wants) my 
pity, it's kind of painful for me to see Ilias making the exact same mistakes 
I did, and then grew out of -- and frustrating when he refuses to hear a word 
of it.

Hopefully this is useful, or at least interesting. Thanks for your patience, 
whoever's actually read this far. At the very least, now you see why it's so 
hard for me to actually not feed this troll.