Julia vs Tcl

Julia runs almost as fast as (and in fact in some cases faster than) C code.

Dynamic and high level, but does not isolate the user from properly thinking about types. Can do explicit type signatures which is great for teaching structured thinking.

Out of the box Julia has a very good Read-Eval-Print-Loop, which both completes functions and types, as well as completion based on history of previous statements. It integrates well with the shell and has an excellent online help system.

Julia code is easy to read and avoid a lot of unnecessary special symbols and fluff. It uses newline to end statements and "end" to end blocks so there is no need for lots of semicolons and curly braces. It is regular in that unless it is a variable assignment, function name always comes first. No need to be confused about whether something is a method on an object or a free function.

Unlike Python and Ruby, since you can annotate the types a function operates on, you can overload function names, so that you can use the same function name for many data types. So you can keep simple descriptive function names and not have to invent artificial function names to separate them from the type they operate on.

The Julia language is written in itself to a much larger extent than most other languages, so a budding programmer can read through the depths of the standard library and learn exactly how things work all the way down to the low-level bit-twiddling details, which can be englightening.

Julia has built in n-dimensional arrays similar in functionality as Python's numpy.

You can have multiple functions with the same name, but doing different things depending on function arguments and argument types.

Julia requires no boilerplate code – a beginner needs to write only the parts they care about. This combined with the REPL provides the best learning experience available.

Julia provides a high level of abstraction, making platform-independent programming trivial and easing the learning curve.

You can perform operations on scalars, for example 2^2 or [1, 2, 3].^2.

Julia allows you to edit Julia code in the language itself and write powerful macros. It is a great introduction to metaprogramming features

The Julia REPL allows quickly testing how some code behaves and gives access to documentation and package management immediately in the REPL.

Unlike *sh Tcl has a rich standard library.

Unlike in sh you don't need to quote your variable substitutions ('"$1"').
Expanding of arguments occurs mostly explicit and if yet expected in-place (e. g. using eval or subst) it follows strict and well clear rules.
So exec test $argv would execute test with single argument.
And appending {*} before $argv would execute test with all arguments (list expansion).

With a little care you can have the same script work on Linux, *BSD, OS X and Windows.

You can expect a reasonably recent version of Tcl to either installed or available in the repositories of any popular open source *nix.

Tcl can operate at the same level of abstraction as the POSIX shell, which makes it easier to manipulate the output of other programs.

Tcl enables easy deployment through self-contained binaries known as starpacks.

Want to run something 5 times? Here you go: set i 0; time { puts done-[incr i] } 5
If you need real conditional cycle? Not a problem: for {set ready 0; set i 1} {$i <= 100 && !$ready} {incr i} { if {[exec do-some-thing] eq "ready" } {set ready 1} }
Want to measure performance of something or repeat it max 300 times and not longer than 1 seconds? Very simple: timerate { after 20 } 1000 300
How about notifying yourself when some http-server is back online? Sure thing: while {[catch { close [socket localhost 80] }]} { after 1000 }; puts "\7\7\7ONLINE!"
And you can do it also fully asynchronously using events etc.