Tcl was never meant for that, the Ousterhout way would be to extend Tcl with the data structure written in C. Now Lua has knocked Tcl crown of "designed from scratch with embedding in mind" but at that time Tcl was indeed quite unique and one of the easiest to embed. This in a backhanded way inspired Guile: scheme intended to be embedded and/or extended.

Talking about Guile, lots of fun things happening there lately. wiki.tcl.tk is a lot of fun too.

> at that time Tcl was indeed quite unique and one of the easiest to embed

Could you please explain why some languages are better at being "embedded and/or extended"? Why would Guile be simpler to embed than Ruby?

The Tcl shell itself (tclsh, which is many people's only interface with Tcl) is just a REPL that uses libtcl. The Tcl library is written in C, and built to be easy-to-use and powerful. Tcl also has an incredibly stable API/ABI which allows for a "stubs mechanism"[0] which is quite a nice, powerful facility that allows for seamless fixes to your Tcl-dependant work.

[0] http://www.tcl.tk/doc/howto/stubs.html

Great points. Something I feel that Tcl really got right and Python did not is handling concurrency. The Tcl way is to run the different interpreters in different threads and communicate between them by message passing but without the need for serialization - deserialization. They had this from the very beginning.

Yes. For multithreaded code, instead of deciding where/how to put interpreter locks (like Python's infamous GIL (global interpreter lock)) to manage low-level sanity wrt sharing data, Tcl punted and lets each interpreter run unfettered.

This is called apartment model [0] threading.

[0] https://msdn.microsoft.com/en-us/library/aa261361(v=vs.60).a... (this is a Microsoft VB article, with nothing to do about Tcl specifically, but does nicely explain the apartment threading model)

Edit: s/let's/lets/

Short answer: size, API and ease of resource management.

My comment was more about the state then than the state now. At that time few, if any languages were designed from scratch to be extended and embedded. Tcl and Guile, to my knowledge were among the first. Tcl interpreter is a library. IMO Guile has grown beyond that charter and is more of a stand-alone Scheme now, but one that can be easily embedded / extended, but so is Chicken I guess.

In addition to what others have mentioned, Tcl also has the speedtables extension, which is absurdly powerful for a lot of tasks.

https://github.com/flightaware/speedtables

You must not have used dicts, lists, associative arrays, or the sqlite intererface to Tcl.

Have you seen Tcl's dictionary construct? Its built in and extremely flexible in creating data structures, as you can define them from the ground up.