Noções básicas em

Sobre Noções básicas

Julia é uma linguagem de programação dinâmica e fortemente tipada. O estilo de programação é principalmente funcional, embora com mais flexibilidade do que em linguagens como Haskell.

Há um sistema de tipos forte e versátil, que vai se tornar importante em conceitos posteriores. Na prática, Julia normalmente infere um padrão adequado a partir do contexto.

Apesar da ênfase na legibilidade, que faz Julia parecer uma linguagem de script como Python e Ruby, o código Julia é compilado antes de rodar. O compilador Just In Time (JIT) produz código altamente otimizado para cada função conforme ela é encontrada, o que leva a uma alta velocidade de execução.

Julia não é uma linguagem orientada a objetos, e não existe uma hierarquia de classes como a que é central em muitas outras linguagens.

Em vez disso (e por favor, não entre em pânico ao ler isto!), Julia se apoia em:

• Uma hierarquia de tipos.
• Funções componíveis (projetadas para se combinar facilmente, de maneiras versáteis e poderosas).
• Despacho múltiplo, ou seja, funções podem ser chamadas com um número variável e diferentes tipos de argumentos.

Esses termos um tanto confusos devem ficar mais claros conforme avançamos pelo programa do curso.

A documentação oficial contém muitas informações valiosas para a versão atual, embora possa ser um pouco assustadora para quem está começando.

• Manual
• Tutoriais
• Primeiros passos com Julia
• Notas para programadores Python
• Notas para programadores R
• Notas para programadores C/C++
• Notas para programadores Matlab (essa é uma linguagem proprietária, muito popular entre engenheiros e uma das inspirações para Julia)

Entre os vídeos estão:

• Uma breve introdução a Julia, da equipe do Exercism!
• Uma introdução descomplicada a Julia
• Aprenda Julia com a gente: uma série de 4 partes

Comentários

Incluir comentários no seu código é extremamente importante para ajudar as pessoas a ler seu código e entender suas intenções: talvez outras pessoas, mas também você no futuro. Eles são (em sua maioria) ignorados pelo compilador.

Em Julia, há duas opções:

• Comentários de uma linha começam com #
• Comentários de várias linhas começam com #= e terminam com =#. É possível aninhá-los.

# This is a single-line comment

x = 3  # This is an inline comment

#=
	Multi-line comments can be used for longer explanations.

	They are especially useful to comment out blocks of code during debugging.
=#

Variáveis e atribuição

Para criar uma variável, basta atribuir um valor a ela:

julia> myvar = 42  # an integer (in fact, Int64)
42

julia> bigint = 1_234_567_890  # optionally use underscore as digit separator, for readability
1234567890

julia> name = "Maria"  # strings are surrounded by double-quotes ""
"Maria"

A atribuição "vincula" um valor à variável.

Especificar um tipo é opcional, e na maioria dos casos Julia infere um padrão adequado a partir do contexto.

Tipos são um assunto importante em Julia. Vamos explorá-los melhor em conceitos posteriores. Por enquanto, é melhor não se preocupar com eles.

Ao contrário de muitas linguagens funcionais, as variáveis em Julia podem ser reatribuídas, e você é livre para mudar tanto o valor quanto o tipo vinculado à variável:

julia> myvar = 3
3

julia> myvar = "now a string"
"now a string"

Constantes

Variáveis globais, criadas fora de qualquer função, são:

• Permitidas.
• Às vezes necessárias.
• Geralmente desencorajadas (embora apenas dentro de arquivos *.jl; o REPL funciona de forma diferente).

Se um valor precisa estar disponível em todo o programa, mas não deve mudar, use uma constante.

Colocar a palavra-chave const antes da atribuição permite que o compilador gere código mais eficiente.

Tentar mudar o valor de const por acidente vai gerar um aviso:

julia> const answer = 42
42

julia> answer = 24
WARNING: redefinition of constant Main.answer. This may fail, cause incorrect answers, or produce other errors.
24

Operadores aritméticos

Aritmética funciona, em grande parte, de maneira convencional:

2 + 3  # 5 (addition)
2 - 3  # -1 (subtraction)
2 * 3  # 6 (multiplication)
8 / 2  # 4.0 (division)
8 % 3  # 2 (remainder)
2 ^ 3  # 8 (exponentiation)

Repare que a divisão com / sempre resulta em um número de ponto flutuante.

Vamos voltar a isso em conceitos posteriores, que vão tratar da divisão inteira com div() ou ÷ para truncar e // para obter um número racional.

Funções

Para obter o melhor desempenho de execução, é melhor colocar a maior parte do código dentro de funções. Ter muitas funções pequenas não é problema, ao contrário de algumas outras linguagens.

Há duas maneiras comuns de definir uma função nomeada em Julia:

1. Usando a palavra-chave function

   function muladd(x, y, z)
       x * y + z
   end
   

   A indentação com 4 espaços é convencional para facilitar a leitura, mas o compilador a ignora. A palavra-chave end é essencial: mais parecido com Ruby do que com Python.

   Repare que poderíamos ter escrito return x * y + z. No entanto, as funções em Julia sempre retornam a última expressão avaliada, então a palavra-chave return é opcional. Muitos programadores preferem incluí-la para deixar suas intenções mais explícitas.

2. Usando a "forma de atribuição"

   muladd(x, y, z) = x * y + z
   

   Essa forma é mais usada para definições de função de uma linha ou funções matemáticas, em que o corpo da função é uma única expressão. A palavra-chave return nunca é usada na forma de atribuição.

As duas formas são equivalentes e são usadas exatamente da mesma maneira, então escolha a que for mais legível.

Para invocar uma função, especifique o nome dela e passe argumentos para cada um dos parâmetros da função:

# invoking a function
muladd(10, 5, 1)

# and of course you can invoke a function within the body of another function:
square_plus_one(x) = muladd(x, x, 1)

Pelo fato de nos referirmos a elas como funções "nomeadas", você pode imaginar que também existem funções "anônimas". Elas serão abordadas em um conceito posterior.

Convenções de nomenclatura

Como muitas linguagens, Julia exige que os nomes (de variáveis, funções e muitas outras coisas) comecem com uma letra, seguida de qualquer combinação de letras, dígitos e underscores.

Por convenção, nomes de variáveis, constantes e funções são escritos em minúsculas, e underscores são evitados, exceto quando necessário para evitar confusão.

No entanto, Julia usa Unicode em toda parte, então "letra" é interpretada de forma bastante flexível.

Outros idiomas além do inglês são suportados, assim como emojis (mas, por favor, use o bom senso e escolha algo apropriado).

Em particular, todas as letras gregas amadas pelos matemáticos estão disponíveis (e vários valores úteis já vêm predefinidos):

julia> π   # a built-in constant
π = 3.1415926535897...

Editores que entendem Julia, incluindo o REPL, o Pluto.jl e o VS Code com o plugin de Julia, facilitam a digitação desses caracteres.

Para o π, digite \pi e pressione <Tab>. O que você digitou será substituído pelo caractere grego.

Você vai ver muitos outros exemplos disso em conceitos posteriores.

Na verdade, as abreviações com barra invertida não são algo específico de Julia. Elas vêm do LaTeX, um sistema de composição tipográfica que muitos cientistas e engenheiros usam quase diariamente para escrever relatórios.