To get us started with Julia we cover three basics. Arithmetic operators, name assignment.

## Arithmetic operators

The standard arithmetic operators are addition (`+`

), subtraction (`-`

), multiplication (`*`

), division (`/`

), power (`^`

) and remainder (`%`

). They work as expected and the only one that is different for the Python crowd is power. That one is Matlab consistent. The normal precedence of operations applies. First power. Then multiplication and division. Then remainder. Finally addition and subtraction. Parentheses can be used to change the order of operation.

```
1 + 3 * 2
# 7
(1 + 3) * 2
# 8
2 * 3 ^ 2
# 18
```

In those examples, both sides of the operator are scalars. It gets a little more interesting when at least one of them is a vector or a matrix. Not all of the above operations are defined between vectors and scalars. Only division and multiplication are defined. We create a vector using square brackets (`[]`

) with the elements separated by commas.

```
[3, 1, 4] * 2
# 3-element Array{Int64,1}:
# 6
# 2
# 8
[3, 1, 4] / 2
# 3-element Array{Float64,1}:
# 1.5
# 0.5
# 2.0
```

The other operations are not defined and throw an error.

```
[3, 1, 4] ^ 2
"""
MethodError: no method matching ^(::Array{Int64,1}, ::Int64)
Closest candidates are:
^(!Matched::Float16, ::Integer) at math.jl:885
^(!Matched::Regex, ::Integer) at regex.jl:712
^(!Matched::Missing, ::Integer) at missing.jl:155
...
Stacktrace:
[1] macro expansion at .\none:0 [inlined]
[2] literal_pow(::typeof(^), ::Array{Int64,1}, ::Val{2}) at .\none:0
[3] top-level scope at In[52]:1
"""
```

The reasons for this design choice have to do with Julias focus on linear algebra and are not important here. If we want this operation to work in an element-wise manner, we have to force it explicitly. We can do so using the dot (`.`

). This way we can explicitly force every operator to be applied element-wise.

```
[3, 1, 4] .^ 2
# 3-element Array{Int64,1}:
# 9
# 1
# 16
[3, 1, 4] .+ 2
# 3-element Array{Int64,1}:
# 5
# 3
# 6
```

Now that we have our arithmetic operators, let’s move on to name assignment so we can store the results of our operations.

## Name Assignment

We assign names to values with the `=`

operator using the syntax `name = value`

. Once a name is assigned, we can use the name instead of the value in operations.

```
result_one = 2 + 2
result_two = result_one + 3
# 7
```

Once a name is assigned to a value we can reassign that same name to a different value without problem.

```
result = 2 + 2
result = 10
# 10
```

If we want to assign a name that is not supposed to be reassigned, we can use the `const`

keyword. If we try to reassign a constant name we get an error.

```
const a = 8.3144621
a = 3
"""
invalid redefinition of constant a
Stacktrace:
[1] top-level scope at In[73]:2
"""
```

There are a few rules about the names we can assign. Generally, Unicode characters (UTF-8) are allowed. This means we can do something like this.

```
δt = 0.0001
```

Here we are using the special character delta. If you want to quickly generate such a character, many Julia environments allow you to do this by typing `\delta`

and hitting tab. I recommend using these sparingly, as they might confuse people transitioning from other languages that don’t allow unicode names. On the other hand they might be useful to make your code style more mathy. Not allowed as names are built-in keywords that have special meaning and trying to assign them will result in an error.

```
if = 3
# syntax: unexpected "="
```

If you are interested in more details about variables and name assignments you can take a look at the official documentation. In the next blog post we will take a look at the type system of Julia.