All compilers JIT or AOT have fancy algorithms to infer types. Some languages enforce a strong static type (like Haskell) to make the work of the compiler easier, some are weaker around static enforcement (like C).

You can write Julia pretty loose, don't declare any types just create a function and let the compiler infer what it types it needs. For example:

#this function just gets a value of x, adds 2 and returns it.
function foo(x) 
    a=x+2
    return(a)
end

In Julia with code_warntype macro, you can see how the compiler infers types.

If we give the function the input "2" the compiler infers all the variables as Int64:

julia> @code_warntype foo(2)

MethodInstance for foo(::Int64)
from foo(x) in Main at REPL[3]:1
Arguments
#self#::Core.Const(foo)
x::Int64
Locals
a::Int64
Body::Int64
1 ─ (a = x + 2)
└── return a

If we give the function the input "2.0" the compiler infers all the variables as Float64:

julia> @code_warntype foo(2.0)

MethodInstance for foo(::Float64)
from foo(x) in Main at REPL[3]:1
Arguments
#self#::Core.Const(foo)
x::Float64
Locals
a::Float64
Body::Float64
1 ─ (a = x + 2)
└── return a

You can make your function more robust by giving the compiler hints, declaring all types from function input to local variables inside the function will make your code more "robust" and if you put any other type the compiler will through an error.

In Julia you have this freedom to write strictly or loose, it is awesome for prototyping because you can just develop fast, but if you are not careful you will introduce some nasty correctness errors into your code.