Assembly vs Julia

One of the best ways to learn how a computer actually works is to work your way up from lower level abstractions. Assembly, being only a level above machine code, is low enough level to make it clear how the computer is actually performing a computation, including code flow and loops, but high enough level to not be excessively tedious for the type of small projects that a student would do at the beginning of their first programming class. Use of an assembler with macros can stretch this even a bit further.

Because of its natural syntax and low-level nature, assembly language programs are typically really small and fast.

Unlike other programming languages, in assembly language it is really hard to create a slow and over-bloated program.

A curriculum that involves an embedded component, such as an Arduino or a Raspberry Pi, can encourage students by allowing them to immediately connect their work with 'real systems'. Assembly is the ideal language for getting started with and understanding these devices, and since Assembly can be called from C, the code will still be useful if students move on to C later in the program.

Assembly language syntax is relatively uniform, and so there's less room for a student to get confused by obscure characters, or miss some meaning implied by structure, such as with scoping rules, or call-by-name/value/reference semantics. While there may be a lot of mnemonics to look up, most work involves only a very small subset of them.

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.

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

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 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 provides a high level of abstraction, making platform-independent programming trivial and easing the learning curve.

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 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.

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

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

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