Glenn Vanderburg

I think he was worried about Sun Microsystems involvement[0] w Tcl when John Ousterhout went there[1], too. But mostly seems like a collection of unsolicited strawmen[2]. Also probably love-of-lisp. [0] That any proximity to commerce is evil? [1] https://en.wikipedia.org/wiki/John_Ousterhout [2] https://vanderburg.org/old_pages/Tcl/war/

I think you have JS confused with TCL, the other language that Sun announced was going to be the universal web browser scripting language, right before Java happened. Remember "The Great TCL War of 1994"? Why you should not use Tcl Richard Stallman ([email protected]) Fri, 23 Sep 94 19:14:52 -0400 http://www.vanderburg.org/OldPages/Tcl/war/0000.html

Ousterhout's reply is worth reading: http://www.vanderburg.org/OldPages/Tcl/war/0009.html I can't find where I'd seen it, but RMS certainly wasn't really keen on the idea of a BSD-licensed system becoming popular, either.

For anyone interest in Guile's history (and it is kind of interesting), it was born in the great Usenet Tcl War http://www.vanderburg.org/OldPages/Tcl/war/ It was intended to be GNU's official extension language, but it has never really caught on. That's sort of a shame, because it's actually a pretty nifty scheme implementation.

I think the best comment on this comes from Glenn Vanderburg: http://www.vanderburg.org/Blog/Software/Development/sharp_and_blunt.rd… The money quote here is this: "Weak developers will move heaven and earth to do the wrong thing. You can’t limit the damage they do by locking up the sharp tools. They’ll just swing the blunt tools harder." Which is so very, very true in my experience. Designing a language around the idea of protecting weak developers from bad choices is a recipe for failure and mediocrity. Instead, look toward designing in a way that guides experienced or at least thoughtful developers toward greater success. tl;dr: Don't make bumper cars for people who can't be trusted to drive, make nomex suits and roll-cages for race car drivers.

That's a very different approach. This is closer to using Lisp to generate C, whereas Lua+C usually involves a multilayered design: you write your engine in C or C++, write or generate a simple Lua wrapper for its API, and then the do logic in Lua, moving hotspots to C as necessary. (http://c2.com/cgi/wiki?AlternateHardAndSoftLayers, as they say.) As a bonus, the cross-language boundaries are often natural seams for containing complexity. TCL was also designed with this style of programming in mind, and John Ousterhout describes it pretty well (http://www.vanderburg.org/OldPages/Tcl/war/0009.html). FWIW, LuaJIT is only available for i386 at the moment, though amd64 porting is in progress. Standard Lua is still pretty fast, and it's great for prototyping. It's a good idea to get algorithms and overall design right before spending much time on low-level tuning.

> There are kinds of making other than engineering. True enough. But the piece argues (I am the author) that software engineering is not making, it's designing. > Carpentry is not engineering. Cooking is not engineering. Carpentry is a craft, but furniture design can be engineering. Cooking dinner is a craft, but designing the menu and production process for a chain restaurant is definitely engineering. > Before you can declare that making software is (or can be) engineering, you have to be able to explain why those things aren't. My position is that they are (or can be), when analysed in an analogous way. You've asserted that they self-evidently are not, even in the absence of a rationale for why. I simply don't agree. > My tentative theory is that engineering has rigorous ways to check whether a design will work before it is manufactured I appreciate you sharing your theory! However, I believe you'll find the history of engineering has largely been one of people doing stuff first and then later finding ways to reduce the cost by doing analysis. I highly recommend watching one of Glenn Vanderburg's "Real Software Engineering" talks for a more in-depth treatment of that subject: http://vanderburg.org/speaking/ > A mechanical engineer might need to draw a detailed design, but can then check it rigorously with finite element methods. That's great, but finite element analysis won't tell you e.g. where water might pool causing a structure to deteriorate, or that a…

I have used Lisp, Scheme, Prolog (and multiple dialects of each) for extended periods in large projects. Each was a pleasure to work with. They all have their own advantages. I am not sure if there is value in arguing over x feature of one language vs. y of another. As a matter of fact, it was fun to write Prolog interpreters in Lisp, and Lisp interpreters in Prolog, for example. (Many courses / textbooks (used to) present these as side projects to do and the task is simpler than it sounds.) One could say Tcl is really an extension of Lisp or Prolog in its core concepts of syntax, data and program equality, style of interpretation, etc. I agree wholeheartedly with the last paragraph of Mr. Ousterhout's reply here - and I must say, a smart, classy and almost Tcl-ish way of a jab at its distractors: http://vanderburg.org/old_pages/Tcl/war/0009.html I came across Tcl/Tk while doing Motif in a large C-based project. I simply couldn't believe how powerful, simple and succint Tk was compared to Motif (or anything else since). And it ran on Windows, Unix, Linux and Mac OS, to boot. It was too late for that project to switch, but all my other projects have used Tk if they ever needed a UI. Similarly with Tcl. I still think the best introduction is Mr. Ousterhout's original Tcl/Tk book. It stands as one of the best language books on my shelf. Combined with Tk, one can put together a working application prototype in no time. Of course, this was eons ago. Nowadays, Tcl…

"Ousterhout's reply is worth reading: http://www.vanderburg.org/OldPages/Tcl/war/0009.html An excerpt, which (imo) should be quoted more often "Language designers love to argue about why this language or that language must be better or worse a priori, but none of these arguments really matter a lot. Ultimately all language issues get settled when users vote with their feet. If Tcl makes people more productive then they will use it; when some other language comes along that is better (or if it is here already), then people will switch to that language. This is The Law, and it is good. The Law says to me that Scheme (or any other Lisp dialect) is probably not the "right" language: too many people have voted with their feet over the last 30 years. I encourage all Tcl dis-believers to produce the "right" language(s), make them publically available, and let them be judged according to The Law."

Guile always surprised me not because of anything LISPy, but because of its relationship with TCL https://vanderburg.org/old_pages/Tcl/war/

I think there were several factors. While Tk (one of Tcl’s major killer apps) looked good on Windows and Mac, it retained the Motif look and feel for too long on UNIX platforms. This gave the impression of it being obsolete technology and made many people dismiss it for use in serious applications. It lacked a major company championing and investing in it. Its creator Dr. Ousterhout, moved onto other projects. Python, JavaScript, Ruby, and PHP won out on the scripting language popularity contest at the expense of Perl and Tcl. Richard Stallman had very strong opinions about Tcl that also did it no favors. This was known as the “Tcl War.” https://vanderburg.org/old_pages/Tcl/war/

So scripting languages of the future are pretty much programming languages. Stallman was right once again: https://vanderburg.org/old_pages/Tcl/war/0000.html

Arguments against Tcl like: https://vanderburg.org/old_pages/Tcl/war/0000.html aside, I found Tcl/Tk along with with the extension Expect: https://en.wikipedia.org/wiki/Expect to be a powerful way to do automation. In the '90s, I automated a process of migrating data from a mainframe to Unix workstations using a Tk GUI run by end users which generated Tcl/Expect scripts to download, convert, and verify massive amount of files in a batch.

But it is bananas. https://vanderburg.org/old_pages/Tcl/war/0018.html Tcl was my first language, and I enjoy it very much. But I hope I will never have to write anything serious in it. And I write Perl for a living.

Stallman was criticising the lack of arrays etc in Tcl which stops it from being used for building complex applications. Tcl author John Ousterhout responded[1] to this by saying that Tcl is a mere glue language and not a replacement for C/C++ and we need both type of languages. If you look at today's language landscape, you have langauges like C, C++, Java etc occupying the "serious" niche and languages like Python etc occupying the "glue" niche ( although sometimes these languages do exchange roles ). The "glue" languages that succeeded did have support for arrays etc. I think both parties have been proven right, at least partially. [1] http://vanderburg.org/old_pages/Tcl/war/0009.html

Back in 1994 rms told us all we should not use Tcl, that GNU was building their own scripting language. True believers have been using Guile ever since. http://vanderburg.org/old_pages/Tcl/war/0000.html

Given that Guile was basically launched by an RMS FUD attack on Tcl more than 20 years ago, 6 years seems like a rounding error. http://vanderburg.org/old_pages/Tcl/war/

There was an interesting article by Ousterhout (Tcl creator) about scripting languages versus system programming languages some years ago. I think I read it in one of the print computer magazines that existed at the time - Software Development Magazine, Unix Review, Dr. Dobb's Journal, C User's Journal, or some such. I wonder whether he was inspired to write that article after this post (mentioned elsewhere in this thread): http://vanderburg.org/old_pages/Tcl/war/0009.html

tl;dr: John Ousterhout's reasonable reply: http://vanderburg.org/old_pages/Tcl/war/0009.html , done (Submitted page looks like an Usenet Who's Who index ;-)

He made a war against it http://www.vanderburg.org/OldPages/Tcl/war/0000.html

Since today seems to be Tcl Day, I thought I'd submit this: the beginning of the famous Tcl War. Here is a direct link to John Ousterhout's reply: http://www.vanderburg.org/OldPages/Tcl/war/0009.html

And remember September 1994 when RMS launched the TCL War with "Why you should not use TCL"? http://www.vanderburg.org/OldPages/Tcl/war/0000.html

Obligatory link to Stallman's "Why you should not use Tcl". http://www.vanderburg.org/OldPages/Tcl/war/0000.html This set off a war a long time ago, in a galaxy far far away. Edit: This has been downvoted twice now. Could be accident, but could be that people think I'm saying you shouldn't use Tcl. I've never used Tcl and hold no strong opinions about it. I'm simply linking to a piece of usenet history.

Surprisingly enough, this was not among the reasons cited in RMS's original "Why you should not use Tcl" post: http://www.vanderburg.org/OldPages/Tcl/war/0000.html

Per http://vanderburg.org/old_pages/Tcl/war/0000.html Stallman's argument at the time was: "a language for extensions should... be a real programming language, designed for writing and maintaining substantial programs... The first Emacs used a string-processing language, TECO, which was inadequate. We made it serve, but it kept getting in our way. It made maintenance harder, and it made extensions harder to write... Tcl was not designed to be a serious programming language. It was designed to be a "scripting language", on the assumption that a "scripting language" need not try to be a real programming language. So Tcl doesn't have the capabilities of one. It lacks arrays; it lacks structures from which you can make linked lists. It fakes having numbers, which works, but has to be slow. Tcl is ok for writing small programs, but when you push it beyond that, it becomes insufficient. Tcl has a peculiar syntax that appeals to hackers because of its simplicity. But Tcl syntax seems strange to most users."

> TCL I actually know the answer to that one! > The principal lesson of Emacs is that a language for extensions should not be a mere "extension language". It should be a real programming language, designed for writing and maintaining substantial programs. Because people will want to do that! > Another lesson from Emacs is that the way to make sure an extension facility is really flexible is to use it to write a large portion of the ordinary released system. If you try to do that with Tcl, you will encounter its limitations. > Tcl was not designed to be a serious programming language. It was designed to be a "scripting language", on the assumption that a "scripting language" need not try to be a real programming language. So Tcl doesn't have the capabilities of one. It lacks arrays; it lacks structures from which you can make linked lists. It fakes having numbers, which works, but has to be slow. From Why you should not use Tcl by Richard Stallman [1]. [1] https://vanderburg.org/old_pages/Tcl/war/0000.html