Second, null denominations usually introduce names -- whether for variables, types, functions, lifetimes, macros, etc. One exception to this are value expressions ("hello", 8, 10+10 are examples), which either appear on the RHS of variable/const declarations, as actual parameters in function invocation, create "no-op" expressions when appearing on their own (a bit weird) or -- when they're the last expression in a block -- sometimes indicate the value returned by the block. The other exception would be directive type constructs - eg directives to import names from another module, directives to give hints to the compiler, etc.
The golden rule of good language design, as I see it, is this: null denominations must begin with a fixed and unique token. The only permissible exception should be for assignment; an exception which exists because variable assignment is so common that requiring a prefix would be insufferable.
Julia breaks this rule for global variables. (Fair enough, Python also commits this error, but it's a mistake and a source of bugs!) But wait, there are also "const" bindings and "local" bindings -- where it gets it right, but now your syntax isn't consistent. So now you need to keep in your head these nuances -- and know the difference between a soft and hard scope -- when you want to write a function which modifies a function using macrology.
As a point of taste on the choice of prefix token: introduction of variables through "local" is just as weird as C++'s "auto". (And at least Bjarne Stroustroup had an excuse for that choice.) Anyone who introduces a global variable in a local scope should be punished imho, so there's no need to say "this is a local variable", it's obvious from the fact that the name is introduced inside a function. Instead, my personal preference is to introduce constants through "let", and variables through "var". The former is well-known to anyone numerate, and the latter is ubiquitous in software engineering. Both read well; they're as close as possible as you can get to constructs in English.
Julia breaks the golden rule again with its succinct, Mathematica-style notation for function definition. I get that it wants to appeal to Mathematica users, but Python already proved you don't need to do that. This is a programming language; brainy types, like mathematicians and physicists, aren't going to be flummoxed by an unfamiliar notation for function definition, or irritated by having to type a few extra characters.
I mention macrology; it's not just that. Let's say you want write a syntax highlighter -- you need to take into account all that weirdness. If null denominations have a fixed & unique prefix, parsing is easy-peasy.
This is not the only thing that's weird, I'm not a huge fan of the use of '=' within for-expressions, but that's just taste.
In what way? It's more-or-less the same syntax as Ruby and Elixir, just with different keywords. Like as much as I love Zig, Zig's syntax is way weirder than Julia's IMO (and none of 'em hold a candle to the weirdness of, say, Erlang or Haskell or Forth or Lisp).