Julia is not at the stage of development where changes like this are made. The language has been fully developed, stable and non-breaking for two years since the 1.0 version was released. Even then, disruptive changes like this would not have been considered without very strong cause. For these kinds of changes to be plausible, you would have had to have suggested them some five years ago or more.
Julia uses the quite common convention that types are capitalized. This helps people reading code understand what is happening—which names are types and which are not.
Why is there an exclamation mark for pop !(Array1)
? Why not just pop(Array1)
? The exclamation mark is what we are familiar with as a not operator.
As explained above, Julia uses the convention that function names ending with !
mutate one of their arguments. This convention has been extremely successful and is certainly not something we would consider changing. Like the capitalization convention, it helps people reading code understand what is happening. If a function modifies an argument, it’s quite important that one be aware of that both when writing and reading the code. Also, mutating functions are somewhat dangerous, so it makes sense that they be somewhat harder to type.
Could you please substitute =>
with :
and for specifying the typing, dict<string, int>
is so much more accessible on the keyboard, easier to type, readable and looks so much better.
The a:b
syntax is already used to construct range objects, so it is not available.
Case usage of functions like SubString()
could perhaps be substring()
or subString()
.
Again, SubString
is a type so it is capitalized.
A lot of these requests seem to have to do with wanting to avoid using the shift key, which would really massively reduce the amount of valuable ASCII real estate available (cutting it fully in half). Moreover, they seem to focus on minimizing the effort of typing code, whereas the conventions are designed to help people read and understand code. Since code is written once but read many times, it is far more important to optimize a language to be easily understood than to make it as easy to type as possible. Knowing at a glance which names are types and which functions mutate things are both useful and important. Much more important than avoiding hitting the shift key sometimes.