DEV Community: Patrícia Villela

Símbolos de APL: "Estrela" e "Log"

Patrícia Villela — Fri, 25 Nov 2022 11:00:00 +0000

AVISO! Essa série de artigos usará exemplos rodados em Dyalog APL, a implementação da Dyalog.

AVISO 2! Esse artigo contém exemplos de código. Se você quiser rodá-los, copie e cole as linhas identadas à direita (as linhas identadas à esquerda são os resultados) nesse site: https://tryapl.org

Garçom, manda mais dois símbolos aí!

Estrela (`*`)

A função monádica do * é "exponencial" ("Exponential" na documentação).
A função "exponencial" retorna e elevado ao argumento.

      *1 2 3
2.718281828 7.389056099 20.08553692

e é a constante de Euler, base dos logaritmos naturais.

A função diátida de * é "exponenciação" ("Power" na documentação).
Essa função retorna a exponenciação com o argumento da esquerda como base e o da direita como expoente.

      2*3
8

Log (`⍟`)

A função monádica do ⍟ é "logaritmo natural" ("Natural Logarithm" na documentação).
O retorno dessa função é o logaritmo natural (aquele com base e).

      ⍟1 (*1) 2
0 1 0.6931471806

O segundo elemento do vetor é e. É evidente que o logaritmo natural de e é 1.

A função diática do ⍟ é "logaritmo" ("Logarithm" na documentação). O retorno dessa função é o logaritmo com argumento da esquerda como base e o argumento da direita como logaritmando.

Conclusão

Com essas duas novas funções finalizamos as funções aritméticas da APL!
Esse artigo foi menor ainda, mas não há tanto mais o que dizer!

Até a próxima!

Símbolos de APL: "Vezes" e "Divisão"

Patrícia Villela — Fri, 18 Nov 2022 11:00:00 +0000

AVISO! Essa série de artigos usará exemplos rodados em Dyalog APL, a implementação da Dyalog.

AVISO 2! Esse artigo contém exemplos de código. Se você quiser rodá-los, copie e cole as linhas identadas à direita (as linhas identadas à esquerda são os resultados) nesse site: https://tryapl.org

Nesse artigo vem mais 2 símbolos!

Vezes (`×`)

A função monádica do × é "direção" ("Signum" na documentação).
A função "direção" retorna o sinal do argumento

3 é positivo, -10 é negativo e 0 é zero. Esse passo é o comum.

      ×3J4
0.6J0.8
      3J4÷|3J4
0.6J0.8

No caso do número complexo a função é um pouco mais complexa. Ela é a divisão do número pela sua magnitude.

      2×3
6

No entanto há uma diferença de com fazemos multiplicação de matrizes. Quando multiplicamos matrizes, além de a restrição ser apenas que o número de colunas de uma deve ser igual ao número de linhas da outra, cada elemento da matriz resultante é a soma dos produtos dos elementos de cada coluna de uma matriz por cada linha da outra matriz.

A matriz

1   2   3
4   5   6
7   8   9

multiplicada pela matriz

1   2   3
4   5   6
7   8   9

resulta na matriz

30  36  42
66  81  96
102 126 150

No entanto a razão de ser da APL foi uma necessidade de regularização da notação matemática. Por isso a multiplicação de matrizes funciona da mesma maneira que a adição, elemento a elemento.

      3 3⍴2
2 2 2
2 2 2
2 2 2
      (3 3⍴2)×3 3⍴2
4 4 4
4 4 4
4 4 4

Divisão (`÷`)

A função monádica do ÷ é "recíproco" ("Reciprocal" na documentação).
O retorno dessa função é o inverso do agumento.

      ÷1 ¯2 1J2
1 ¯0.5 0.2J¯0.4
      ÷0
DOMAIN ERROR: Divide by zero
      ÷0
      ∧

O recíproco de 0 claro que dá um erro de divisão por zero.

A função diática do ÷ é "dividir" ("Divide" na documentação). A divisão também funciona da maneira esperada.

      2 0 5÷4 0 2
0.5 1 2.5

Notem que há mais uma incongruência com a matemática padrão. Em APL, 0÷0 é 1!

Conclusão

Esse artigo foi menor mas ainda assim cobrimos dois outros operadores aritméticos da APL.
Bom APL!

Até a próxima!

Símbolos de APL: "Mais" e "Menos"

Patrícia Villela — Fri, 11 Nov 2022 11:00:00 +0000

AVISO! Essa série de artigos usará exemplos rodados em Dyalog APL, a implementação da Dyalog.

AVISO 2! Esse artigo contém exemplos de código. Se você quiser rodá-los, copie e cole as linhas identadas à direita (as linhas identadas à esquerda são os resultados) nesse site: https://tryapl.org

Nesse artigo vamos falar de uma vez de 2 símbolos! Mas não se assustem, eles são bem simples porque suas funções já são conhecidas por nós. No entanto, precisamos passar rapidamente por um conceito central da APL.

Monádico vs Diático

Em primeiro lugar, não devemos confundir "monádico" aqui com "monads" em linguagens como Haskell. Os termos monádico e diático aqui querem dizer, respectivamente, que a função recebe um ou dois argumentos.

Mais (`+`)

A função monádica do + é "conjugar" ("Conjugate" na documentação).
A função conjugar retorna o argumento passado com a parte complexa negada quando aplicável.

(o formato de números complexos é aJb, com a sendo a parte real e b sendo a parte imaginária)

      a b c d e←2 2J2 2J¯2 't' ⎕NULL
      +a ⍝ número real retorna igual
2
      +b ⍝ complexo inverte parte complexa
2J¯2
      +c
2J2
      +d ⍝ strings de caracteres não mudam
t
      +e ⍝ valor null não muda
[Null]

A razão para os valores [Null] e strings de caracteres retornarem o mesmo é histórica e não vem ao caso, mas tem a vez com o uso desse símbolo para a função "identidade", que será tratada em outro artigo.

A função diática do + é "soma" ("Add" na documentação). A soma funciona da maneira esperada. Porém, há algumas propriedades interessantes.

      1+1
2
      1+1 2 3 4
2 3 4 5
      1 2 3 4+5 6 7 8
6 8 10 12
      1 2+3 4 5
LENGTH ERROR: Mismatched left and right argument shapes
      1 2+3 4 5
         ∧
      1+3 3⍴1
2 2 2
2 2 2
2 2 2
      (3 3⍴2)+(3 3⍴1)
3 3 3
3 3 3
3 3 3
      3 3 3+3 3⍴1
RANK ERROR: Mismatched left and right argument ranks
      3 3 3+3 3⍴1
           ∧

A primeira operação é de dois valores escalares (arrays sem dimensão). Ocorre a soma normalmente.
A segunda operação é de um valor escalar e um vetor (array com 1 dimensão). Nesse caso o valor escalar é somado a cada um dos elementos do vetor.
A terceira operação é uma soma de dois vetores. Nesse caso, como ambos os vetores tem a mesma dimensão (4 elementos), cada índice de um vetor é somado a cada índice do outro vetor.

A regra básica é que é possível somar um escalar com qualquer outro array de qualquer dimensão e dois arrays de mesmas dimensões. No primeiro caso todos os elementos do array serão acrescidos do valor escalar e no segundo caso cada elemento de um dos arrays é acrescido do valor do elemento correspondente.

Menos (`-`)

A função monádica do - é "negar" ("Negate" na documentação).
A função negar retorna o argumento negado.

      -¯2.5 1e20 3j¯4
2.5 ¯1E20 ¯3J4
      -'t'
DOMAIN ERROR
      -'t'
      ∧
      -⎕NULL
DOMAIN ERROR
      -⎕NULL
      ∧

Note que há também um exemplo parecido com o de + usando t e ⎕NULL como argumentos de "negar". O erro DOMAIN ERROR é comum para qualquer uma das funções aritméticas quando usadas com caracteres e valores nulos, e só não ocorre com + por razões históricas.

A função diática do - é "subtração" ("Subtract" na documentação). A subtração funciona da maneira esperada.

      6-1-2
7
      5-2
3
      4-1 2 3 4
3 2 1 0
      1 2 3 4-5 6 7 8
¯4 ¯4 ¯4 ¯4

A regra da subtração é a mesma da soma e de qualquer outra operação aritmética: é possível subtrair um escalar do outro, um array de um escalar e dois arrays de mesma dimensão.

Atenção! O símbolo - e ¯ são diferentes.

O resultado é o mesmo, mas no primeiro está sendo executada a função "negar" com "2" como argumento. No segundo está sendo criado o número "-2".

Conclusão

Falamos dos dois primeiros operadores aritméticos da APL e ainda falamos de funções monádicas e diáticas. Espero que estejam gostando ^^

Até a próxima!

Símbolos de APL: atribuição

Patrícia Villela — Fri, 04 Nov 2022 14:14:43 +0000

AVISO! Essa série de artigos usará exemplos rodados em Dyalog APL, a implementação da Dyalog.

AVISO 2! Esse artigo contém exemplos de código. Se você quiser rodá-los, copie e cole as linhas identadas à direita (as linhas identadas à esquerda são os resultados) nesse site: https://tryapl.org

O primeiro símbolo que vou apresentar é ←.

Esse é o símbolo de "atribuição" ("Assignment" na documentação). A maioria das linguagens de programação usam o símbolo = para esse fim. Em APL, = é reservado para comparação de igualdade.

      a←1
      a
1

A primeira linha atribui o valor 1 para a variável a e a segunda linha a exibe. A terceira linha é o retorno da segunda.

A atribuição não é restrita a valores escalares (que em APL são arrays com uma dimensão).

      a←1 2 3 4
      a
1 2 3 4

A atribuição também serve para outras coisas, como redirecionamento para o display usando o caracter ⎕ (é um quadrado mesmo, chamado "Quad", não é erro de encoding. Esse símbolo será elaborado em outro artigo).

      ⎕←a←1
1

Assim como em linguagens mais populares hoje em dia, é possível atribuir uma modificação, como por exemplo um incremento.

Também é possível fazer atribuição de arrays de mesmas dimensões. O efeito disso é a distribuição dos valores nas variáveis listadas.

      a b c←1 2 3
      a
1
      b
2
      c
3

Por enquanto é isso. Em resumo pode-se entender esse símbolo como um símbolo de transferência de valor, tanto para uma variável, quanto para o display.

O que é o Advent Of Code?

Patrícia Villela — Thu, 03 Nov 2022 16:35:58 +0000

O que é?

Pra saber o que é o Advent Of Code, precisamos saber o que é o "advento".

Advento

Advento é um período que antecede o Natal, do dia 27 de novembro ao dia 24 de dezembro. As suas origens não vem ao caso. O mais importante é entender uma prática que acontece nesse período.

Há uma tradição que consiste em guardar um docinho em cada uma de 24 caixinhas numeradas, cada uma representando um dia de dezembro antecedendo o Natal. A cada dia a dona desse calendário vai lá e pega um dos doces (que podem ser substituídos por toda sorte de coisa, inclusive cartas) e come. E nessa tradição que oi Advent Of Code se inspira.

Então o que é?

É uma série de desafios que vai do dia primeiro ao dia 24 de dezembro, um desafio por dia.

Advent Of Code

Todo Advent Of Code começa com uma história sobre o Papai Noel se preparando para entregar os presentes de Natal. No entanto, algo acontece e é seu trabalho como desenvolvedora ajudar o bom velhinho a se livrar dos problemas e dar um Natal feliz a toda gente.

Como participar?

Basta acessar https://adventofcode.com e se autenticar. Os problemas aparecem todo dia à meia-noite (UTC-5, ou seja, 2 da manhã para quem está no horário de Brasília) e ficam disponíveis pra sempre. Inclusive, se você quiser fazer um esquenta no de 2021, fique à vontade.

Ah, e o desafio é agnóstico no que diz respeito à linguagem. Além disso, não é necessário usar a mesma linguagem o desafio todo, então mandem ver!

E você?

Eu pretendo participar esse ano, assim como participei ano passado. No entanto, pretendo completar dessa vez, nem que eu tenha ajuda de outras pessoas.
Vou começar com APL. Quando eu vir que não consigo mais continuar com essa linguagem porque eu não tenho tanta experiência com ela assim, vou tentar com alguma outra e depois arranjar uma solução em APL no discord que eu faço parte.

Pretendo também relatar isso por meio de vídeos no YouTube e artigos aqui.

Ansiosas?

Expressões Regulares IV - as três regras da regex I - backtracking

Patrícia Villela — Thu, 15 Sep 2022 22:35:05 +0000

Alguns anos atrás eu comecei a falar que há três regras para se usar expressões regulares

não use regex
reconsidere se você precisa usar regex
conheça sua engine

Pode parecer engraçado eu usar duas regras para desencorajar o uso de regex sendo que eu estudo isso e estou inclusive escrevendo uma série de artigos dedicados a ensinar como usá-la, mas eu vou explicar.

A primeira e a segunda regra são na verdade a mesma e estão duplicadas para efeito de ênfase.

Quando começamos a aprender regex (e até quando já sabemos há um tempo), ficamos tentados a usar para solucionar qualquer problema. Daí fazemos coisas como essa para validar uma data.

/^(?:([0-1])|(2)|(3))(?(1)[0-9])(?(2)(?:([0-8])|(9)))(?(3)[0-1])\/
(?:(01|03|05|07|09|11)|(04|06|08|10|12)|(02))(?(3)(?(8)(?!)))\/\d*
(?:(04|08|12|16|20|24|28|32|36|40|44|48|52|56|60|64|68|72|76|80|84|
88|92|96)|(\d\d))(?:(00)|(04|08|12|16|20|24|28|32|36|40|44|48|52|56|
60|64|68|72|76|80|84|88|92|96)|\d{2})(?(2)(?(5)(?(8)(?(11)(?(9)|
(?!))|(?(12)|(?!))))))/

(podem testá-la, a propósito 😉 https://regex101.com/r/aqEsf1/1)

Essa atrocidade de regex valida não somente o formato da data (que precisa ser dd/MM/yyyy), mas também valida se a data é válida. Dia 31 de setembro não é validada. Dia 29 de fevereiro de 2021 não é validada. Eu tenho um certo orgulho dessa regex, francamente (sim, eu que fiz).

Porque não a usamos então? Eu apresento dois motivos.

O primeiro é mais óbvio: essa regex é incompreensível e um pesadelo de se mexer. Se houver algum bug nela, qualquer tentativa de mudá-la será muito custosa.
O segundo não é tão óbvio, mas deve ser simples de entender: essa regex é muito custosa para a engine.

Para explicar, precisamos falar sobre como a engine funciona internamente. Apertem os cintos e vamos lá!

Funcionamento interno das engines de regex

Embora cada engine tenha uma particularidade, podemos dividí-las em duas categorias: engines text-directed e regex-directed.
Não falaremos de engines text-directed aqui, pois seu funcionamento é trivial porque não existe backtracking e as engines mais usadas são as regex-directed. Vamos a elas então.

As engines regex-directed, chamadas a partir de agora somente de engines, funcionam basicamente da seguinte forma:

Enquanto houver tokens na regex, pegue o próximo token
Tente dar match com o próximo caracter da string
Se houver match, avance para o próximo token da regex e o próximo caracter da string
Se não, volte até uma posição anterior da regex para testar um outro caminho por ela (esse é o backtracking)

Vamos de exemplo. Vamos aplicar a regex /<.*?>/ no texto <span>Teste</span>.

Enquanto houver tokens na regex, pegue o próximo token (<)
Dá match com o próximo caracter da string (<) 1 Houve match, então avança para o próximo token da regex (.*?) e próximo caracter da string (s)
O token .*? é o quantificador lazy que vai dar match no mínimo possível para que a regex seja válida. A primeira tentativa é de um match sem tamanho (match em '').
Dá match, então avança para o próximo token da regex (>) e o próximo caracter da string (s).
Não dá match, então retorna a regex pro token anterior (.*?)
Dá match, pois . dá match em qualquer caracter (exceto quebra de linha), então avança para o próximo token da regex (>) e o próximo caracter da string (p).
Não dá match, então retorna regex (.*?).
.*? deu match em s antes, mas agora precisa dar match em sp. Tudo bem, pois . dá match em qualquer caracter (exceto quebra de linha) e * dá match em mais de um caracter.
Dá match, então avança regex (>) e string (a).
Não dá match. Isso vai se repetir até a regex encontrar na string o caracter >. Nesse caso, ela vai dar match e retornar ok.

Segue um esquema tirado da aplicação RegexBuddy para explicar melhor.

Beginning match attempt at character 0
<
< ok
< backtrack
<s
<s backtrack
<sp
<sp backtrack
<spa
<spa backtrack
<span
<span backtrack
<span>
Match found in 11 steps

(espaços adicionados por clareza)

Dessa maneira, é possível notar que há as engines vão e voltam na string até encontrar uma solução para a regex. Vamos pegar o diagrama do RegexBuddy para uma data e aquela regex.

Beggining match attempt at character 0
ok
1
1
1
12
12
12 ok
12 ok
12 ok
12 ok
12/
12/0
12/0 backtrack
12/0
12/0 backtrack
12/0
12/0 backtrack
12/0
12/0 backtrack
12/0
12/0 backtrack
12/ backtrack
12/ backtrack
12/0
12/0 backtrack
12/0
12/0 backtrack
12/0
12/0 backtrack
12/ backtrack
12/ backtrack
12/ backtrack
12/0
12/02
12/02
12/02
12/02 ok
12/02 ok
12/02/
12/02/ backtrack
12/02/ backtrack
12/02/ backtrack
12/02/ backtrack
12/20/2
12/02/20
12/02/20
12/02/20
12/02/200
12/02/200 backtrack
12/02/20 backtrack
12/02/200
12/02/200 backtrack
12/02/200
12/02/200 backtrack
12/02/20 backtrack
12/02/20 backtrack
12/02/20 backtrack
12/02/20 backtrack
12/02/20 backtrack
12/02/20 backtrack
12/02/20 backtrack
12/02/20 backtrack
12/02/20 backtrack
12/02/20 backtrack
12/02/20 backtrack
12/02/20 backtrack
12/02/20 backtrack
12/02/20 backtrack
12/02/20 backtrack
12/02/20 backtrack
12/02/20 backtrack
12/02/20 backtrack
12/02/20 backtrack
12/02/20 backtrack
12/02/20 backtrack
12/02/20 backtrack
12/02/20 backtrack
12/02/2003
12/02/2003
12/03/2003 ok
12/03/2003 ok
Match found in 81 steps

Um tanto mais complexo que a solução preferida, que em Java seria algo como:

Date date = new Date('12/02/2003');

Pois a implementação do Java já testa se a data é válida ao instanciar o objeto.
É importante lembrar que nenhuma engine de regex tem informações semânticas sobre o texto. Enquanto o Java tem como saber que 12 na data é dia e 2003 é ano, a engine de regex só entende texto.

A mesma coisa para email. Em vez de usar uma regex monstruosa como a seguinte:

(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ 
\t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+
(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:
(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)
?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\
r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[
 \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)
?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t]
)*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[
 \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*
)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)
*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+
|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r
\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:
\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t
]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031
]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](
?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?
:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?
:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?
:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?
[ \t]))*"(?:(?:\r\n)?[ \t])*)*:(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] 
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|
\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>
@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"
(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?
:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[
\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-
\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(
?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;
:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([
^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"
.\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\
]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\
[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\
r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] 
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]
|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \0
00-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\
.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,
;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?
:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[
^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]
]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)(?:,\s*(
?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(
?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[
\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t
])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t
])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?
:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|
\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:
[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\
]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)
?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["
()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)
?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>
@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[
 \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,
;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:
\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[
"()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])
*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])
+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\
.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(
?:\r\n)?[ \t])*))*)?;\s*)

uma solução mais simples é mandar um email para o endereço. Se estiver válido, o email chegará. Para auxiliar o usuário a preencher o formulário, basta verificar com essa regex

.*@.*\..*

ou algo parecido.

A terceira regra será tratada no próximo artigo. Abraços.

Expressões Regulares III - âncoras, limites de palavras e caracteres de palavras

Patrícia Villela — Mon, 12 Sep 2022 14:00:42 +0000

Âncoras

"Âncora" é o nome que damos para os caracteres ^ e $. ^ significa o início da linha e $ significa o fim da linha.
Então se eu tiver a seguinte regex

^[Tt]este

e aplicá-la ao seguinte texto

Teste unitário é um tipo de teste que visa testar
apenas uma unidade de código, como um fluxo determinado de
uma função.

A regex vai dar match apenas no primeiro Teste porque ele está no início da linha, representado pelo ^. A mesma coisa acontece com $.

A regex
nunca$
aplicada no texto

Lembre-se, nunca diga nunca

vai dar match somente no segundo nunca.

Limites de palavras

Limites de palavras é o nome que damos ao caracter especial \b. Ele serve para darmos match no início ou no final de uma palavra.

A regex
\bvel
aplicado sobre o texto
O vel da noiva é invisível
vai dar match apenas na palavra vel, porque \b dá o match no limite da palavra.

Em contrapartida, o caracter \B vai dar match em posições que \b não dá match.

\Bvel
aplicado sobre o texto
O vel da noiva é invisível
dá match no vel de invisível.

Mas como a engine sabe que a palavra acabou? Como ela decide o final da palavra anti-herói? \b dá match no que \w não dá. \w é chamado de word character. Ele dá match em "caracteres de palavras", então as letras do alfabeto, algarismos e underline (_). Algumas implementações, ou flavors, de regex suportam Unicode por padrão, como a engine do Python. Nas que não suportam, o ó de herói não será reconhecido como \w se não for colocada uma flag, que na maioria dos flavors é u. Falaremos sobre flags mais pra frente.
No entanto, nenhuma engine de regex dá match no hífen (-). Então se você quiser que a sua engine dê match em anti-herói, você precisará da seguinte regex

/[\w-]+/u

Assim você engloba tanto todos os caracteres representados por \w e o hífen.
Notem que eu coloquei duas barras (/), uma no começo e uma no final da regex. Esses são os separadores e indicam quando a regex começa e termina. Esses separadores não foram incluídos antes porque não eram necessários para a explicação, mas por conta da flag u, foi preciso incluí-los. Novamente, falaremos sobre flags mais pra frente.

Conclusão

Nessa parte foi a primeira vez que eu falei de flavors de regex. É importante falar sobre isso porque o que a gente chama de regex é na verdade uma especificação. Cada linguagem ou plataforma implementa de uma maneira diferente essa especificação, então agora é a primeira vez que digo uma das regras da regex, que eu mesmo formulei.

Regra 3: conheça muito bem sua engine de regex

Até a próxima.

Expressões Regulares II - classes de caracteres

Patrícia Villela — Sun, 04 Sep 2022 17:24:17 +0000

No último artigo iniciamos no mundo das expressões regulares. Neste presente, continuaremos a expandir nossas ferramentas para aumentar as possibilidades de match falando sobre classes de caracteres.

Classes de caracteres

Classes de caracteres são usadas para podermos identificar diversos caracteres diferentes numa determinada posição. Vamos de exemplo novamente que é sempre mais fácil de explicar:

Paul[ao]

Essa expressão regular descreve tanto Paula quanto Paulo. Isso é feito com a sintaxe [].

Quando uma determinada posição pode conter mais de um caracter, usar uma classe de caracteres é a solução. Também são suportados intervalos de dígitos e caracteres, dessa maneira:

[0-5] => representa os dígitos de 0 a 5.
[f-j] => representa os caracteres de f a j.
[A-Fa-f0-9] => representa os caracteres de a a f, de A a F (regex é case sensitive, então maiúsculas e minúsculas são tratadas de maneira diferente) e os dígitos de 0 a 9. Basicamente, qualquer dígito hexadecimal.

Classes de caracteres também podem incluir caracteres não-alfanuméricos. No entanto, sua utilização muda. Os únicos caracteres entendidos como especiais dentro de uma classe de caracteres são o ], pois significa o fim da classe, ^ no começo da classe, pois significa negação (mais informações à frente) e -, pois indica que estamos falando de um intervalo. Dessa maneira, qualquer caracter que não os citados anteriormente é entendido como literal dentro de classes de caracteres.

Abc[*+] => identifica os textos Abc* e Abc+

Para usar os outros três caracteres (], ^ e -), é necessário escapá-los.

[a-f] => identifica os caracteres de a a f
[a\-f] => identifica os caracteres a, - e f

Se você desejar que a classe de caracteres represente caracteres que não podem ser identificados, utilize o caracter ^ no começo da classe.

[^abc] => identifica qualquer caracter que não os caracteres a, b e c
[^0-9] => identifica qualquer caracter que não seja um dígito

Cautela

É importante ressaltar que classes de caracteres negados ainda assim precisam dar match num caracter. A regex a[^f] não quer dizer "Letra 'a' não seguida da letra 'f'", mas fim "Letra 'a' seguida por um caracter que não seja a letra 'f'". E qual é a diferença?

A regex a[^f] dá match na letra 'a' em Teresa., porque o caracter '.' não é 'f', mas não dá match na letra a em Teresa, pois não há nenhum caracter depois do 'a'.

Conclusão

Sem conclusão dessa vez ^^. Até a próxima parte

Expressões Regulares I - o básico

Patrícia Villela — Tue, 30 Aug 2022 01:46:34 +0000

\d{3}\.?\d{3}\.?\d{3}-?\d{2}

Não, seu navegador não está com problemas de encoding e nem aconteceu do meu gato deitar no meu teclado. Esse monte de caracteres que parecem jogados aleatoriamente é um exemplo de expressão regular.
Expressões regulares, que a partir desse ponto serão chamadas de regexes (singular, regex) são conjuntos de caracteres que descrevem um padrão que será buscado num texto. Um exemplo vai deixar mais claro.

Considere o seguinte texto:

A história de toda a sociedade até aqui é a história de lutas de classes.

Se você quiser extrair a palavra classes desse texto você pode usar a seguinte regex.

classes

Okay, não é muito útil, mas regexes podem fazer mais que isso. Pegue o exemplo a seguir:

Guerra Austríaco-Prusiana de 1866. O problema desta guerra foi discutido nas reuniões do Conselho Geral da Internacional Operária, celebrada nos dias 19 e 26 de junho, e 17 de julho de 1866 de julho. [Nota do MIA].

Se você quiser extrair todos os números desse texto você pode usar a seguinte regex.

\d+

Descrevendo o que está acontecendo:

\d descreve um dígito (0, 1, 2, ..., 9)
+ descreve que o símbolo anterior pode aparecer 1 ou mais vezes.

Dessa maneira, qualquer grupo de dígitos será encontrado. No caso do texto anterior, as seguintes informações serão encontradas:

1866
19
26
17
1866

Com esse segundo exemplo podemos ver um pouco melhor pra que servem regexes. Agora que passamos por isso, vamos começar do começo.

O começo

Nesse primeiro artigo vamos falar sobre caracteres literais, caracteres especiais e quantificadores.

Caracteres Literais

Como descrevemos acima, caracteres literais são caracteres que são encontrados literalmente. Então se houver qualquer caracter literal na regex, ele será procurado literalmente.
E quais são esses caracteres literais? Bom, são todos os caracteres que não são especiais. Vamos a eles, então?

Caracteres Especiais

Os caracteres especiais são caracteres que tem algum uso especial, como representar repetição, caracter opcional ou outras coisas.
O primeiro caracter especial que discutiremos é o caracter \, chamado comumente de contra-barra. Esse caracter faz com que o próximo caracter passe a ser especial se for literal e literal se for especial. Vejamos alguns exemplos:

\d => d é um caracter literal, mas precedido de \, passa a significar qualquer dígito
\+ => + é um caracter especial, mas precedido de \ (também chamado de "escapado"), passa a significar + literalmente.

Outros caracteres especiais são ., que representa qualquer caracter (exceto quebra de linha), ?, que diz que o símbolo anterior é opcional, entre outros. Para uma lista mais completa dos caracteres especiais mais comuns nas engines de regex, clique aqui.

Quantificadores

Quantificadores são úteis para evitar repetições na regex. Por exemplo:

\d{4} é o mesmo que \d\d\d\d

Há alguns tipos de quantificadores. Eles são:

* significa que o símbolo anterior pode repetir 0 ou mais vezes (ou seja, ab* identifica tanto a quando ab, abb, abbbb, etc...)
+ significa que o símbolo anterior pode repetir 1 ou mais vezes (ou seja, ab+ identifica tanto ab, abb, abbbb, etc..., mas não a)
{a,} significa que o símbolo anterior pode repetir a ou mais vezes
{,a} significa que o símbolo anterior pode repetir de 0 a a vezes
{a,b} significa que o símbolo anterior pode repetir de a a b vezes
? significa que o símbolo anterior pode ocorrer 0 ou 1 vez

A regex do começo

Agora você deve ser capaz de entender a regex do começo.

\d{3}\.?\d{3}\.?\d{3}-?\d{2}

\d{3} => 3 dígitos
\.? => um caracter . opcional
-? => um caracter - opcional
\d{2} => 2 dígitos

Dessa forma, essa regex identifica números com formato igual ao de CPFs num texto (validação não é feita nesse caso.)

Conclusão

Expressões regulares são uma ferramenta muito útil para processamento de textos, tanto para validação quanto para busca de informações. Apesar de ser recomendada cautela em seu uso pois o processamento de expressões regulares pode ser bastante complexo, no sentido computacional do termo, devido a uma estratégia chamada de backtracking, sobre a qual falaremos numa parte futura, regex é uma das ferramentas fundamentais no cinto de utilidades do profissional de tecnologia.

Nos vemos na próxima parte.

Quem é a Lissa?

Patrícia Villela — Sat, 27 Aug 2022 18:44:46 +0000

Quem é Lissa para você?

Lissa é um pedaço de um todo. A parte compreensível de um mar de ideias, pensamentos, emoções, razões, traumas, e personalidades, que tá há 15 anos nessa terra com esse mesmo corpo. Tenta todo dia lutar contra seus medos e falhas, e se lapida, tirando o montante, pra sobrar o restante que vale a pena, em busca de se tornar um rubí.

Quem é Lissa para o mundo?

Uma pessoa que faz várias coisas, e não sabe decidir qual vai fazer, então é organizadora, líder de comunidade, produtora de conteúdo, desenvolvedora, influencer e peso chumbo nas treta do twitter.

O quê a Lissa faz atualmente?

Eu trabalho em comunidades, produzindo conteúdo, e organizando eventos, também trabalho com a Letícia Silva, e o William Frantz, em um projeto de preparo para vagas na tecnologia remunerado, então eu também desenvolvo e produzo conteúdo lá.

Não gosto de falar disso publicamente porque é uma fraqueza minha, mas é importante falar disso, então eu tenho que lidar com uma vida dupla. No colégio e em casa eu sou uma pessoa, e na internet, nos meus ambientes, eu sou outra. Em um momento eu uso uma armadura de ferro e lixa, que cansa meu corpo, e machuca a minha pele, e em outro eu não preciso usar esses proteções, mas me torno muito vulnerável e frágil.

Eu sei quando isso tudo isso vai mudar, mas eu ainda preciso esperar.

Como é ser tão influente nas comunidades tendo 15 anos?

Sinceramente, eu não gosto. Eu entendo a intenção positiva de me chamar de prodígio ou muito jovem, mas eu não gosto. Eu só sou assim porque quando criança eu tinha vergonha de brincar, eu convivia com os adultos, e não falava com as outras crianças, então eu tentava me espelhar neles. Então desde cedo eu apaguei minha infantilidade, e comecei a fazer coisas que não eram da minha idade, como organizar comunidades, e lidar com pessoas que tem até mais que o dobro da minha idade.

Então no fim, pra mim é normal porque eu me acostumei, mas olhando pra trás, não acho bom porque tem toda uma parte da minha vida que eu perdi e que eu nunca vou ter de volta, exatamente por ter amadurecido tão cedo.

O que fez você se interessar por tecnologia?

A falta do que fazer. Eu tinha uns 12 anos, e tinha passado por um período muito merda da minha vida, tanto que com 11 eu quase me matei, era questão de um passo. Então como eu não tinha nada mesmo, a tecnologia apareceu pra mim como um vídeo recomendado no Youtube, um tutorial de Python. E eu prestei atenção naquela thumbnail em específico, cliquei, me interessei, e tamo aí hoje em dia.

É por isso que eu não acho que as coisas são aleatórias, elas sempre tem um motivo para acontecerem. Se não fosse aquele exato vídeo, ter sido recomendado pra mim, naquele dia, eu provavelmente nem estaria aqui mais.

O quê são comunidades para você?

Comunidades são espaços de convivência, respeito, troca de ideias e transmissão de conhecimento. Onde podemos encontrar pessoas parecidas com a gente, e chamar outras pessoas para dentro desse ambiente, botando todas essas pessoas juntas em um mesmo lugar, caminhando juntes em busca da revolução.

A organização é única forma de minorias sociais, que também são massas demográficas, mudarem algo no mundo. Como um dia, em uma música ainda sem nome vou cantar:

macho cishet só se for com latéx
pensei e escrevi essa no LaTeX

Como você conheceu as comunidades de tecnologia?

Conheci elas com as lives da Twitch. Eu assistia muito a live do Pokemaobr, e nela a gente começou a formar uma comunidade conforme o tempo, que é a Caverna do Patocórnio. Junto com a Caverna, as mulheres que participavam das lives formaram a Live Coder Girls, que era um grupo de mulheres que faziam ou gostavam de lives. Que depois de um tempo se tornou a Feministech, e quando eu me descobri trans no fim de 2021, eu entrei na comunidade, e depois disso eu só me senti melhor. Achar um grupo que te aceita do jeitinho que você é, é bom demais.

Como foi fundar a Kotlinautas?

Foi uma experiência interessante, eu tinha começado a estudar Kotlin uma semana antes de confundar uma comunidade SOBRE KOTLIN, então eu aprendi enquanto eu produzia e construia a comunidade. É por isso que tem tanto artigo na Kotlinautas feito por mim, porque enquanto eu aprendia, eu produzia conteúdo sobre o que eu tava aprendendo.

Pra ser sincera, eu tô meio desanimada da Kotlinautas pela falta de participação de todes, principalmente de mulheres ou pessoas trans lá. E se tem uma coisa que eu não curto é falta de participação ou engajamento. Mas acontece, diferentes comunidades vão ter engajamentos diferentes.

Quais são seus sonhos?

Conseguir tornar a vida mais confortável pro máximo de pessoas, principalmente mulheres e pessoas trans, que eu puder. Tanto em tech, quanto em outras áreas (vem aí Fundação Lissa 👀).

Eu já achei tantas vezes que a minha vida não valia a pena, que um dos meus maiores desejos é poder perto da minha morte, poder relaxar, e admirar a gota de vida que eu bebi durante aquele tempo. Que a minha passagem nessa terra dessa vez tivesse valido realmente à pena, e que eu fui útil pra alguém. Só nesse momento, eu vou me tornar o rubí que eu tanto falo sobre. Mas por enquanto, enquanto grafite, não vou parar de correr.

Como customizar o prompt do seu terminal

Patrícia Villela — Sat, 18 Jun 2022 02:37:09 +0000

Salve, salve, camaradas!
Para quem usa Linux ou Mac o terminal é uma visão muito comum e familiar. Estamos acostumados a ver coisas como essa:

patricia@patricia-PC:~$

Comum, certo? Nome do usuário, nome do host e diretório atual. No entanto, você sabia que seu prompt poderia ser assim?

Se liga no comando muito louco que patricia vai rodar agora! >

Se você não sabia, vem comigo!

Variáveis de ambiente que controlam o prompt

Há 4 variáveis de ambiente que configuram o prompt

PS1: Essa variável vai definir o que vai aparecer no prompt padrão.
PS2: Essa variável vai definir o que vai aparecer quando seu comando tiver múltiplas linhas (por exemplo num comando for).
PS3: Essa variável vai definir o que vai aparecer quando você usar o comando select. Não se preocupe muito com essa.
PS4: Essa variável vai definir o que vai ser mostrado quando o bash for instruído a mostrar o stack trace de um comando. Não se preocupe muito com essa também.

Dessas variáveis, as que mais serão usadas são as PS1 e PS2, e a primeira muito mais que a segunda.

Bora customizar??

Customizando o prompt

Em primeiro lugar, não fique com medo de "zoar" seu prompt. Qualquer mudança que você fizer é reversível.

Agora que estamos sem medo, vamos colocar a data atual no prompt.

patricia@patricia-PC:~$ PS1="\t $PS1"
20:00:05 patricia@patricia-PC:~$

Que que aconteceu aí?
Na primeira linha a gente modifica a variável PS1 para receber o valor \t $PS1. Esse $PS1 será expandido para o prompt atual, que no meu caso é \u@\h:\w\$. Então o prompt vai ficar \t \u@\h:\w\$.
Agora, como que \t virou a data? Essa é uma "variável" interna usada pro prompt.

\u será expandido para o nome do usuário
\h será expandido para o nome do host (até o primeiro ".")
\w será expandido para o diretório atual (substituindo /home/${USER} por ~)
\$ será expandido para $ quando o usuário for comum e # quando o usuário for o "root"
\t será expandido para a data no formato HH:MM:SS (formato de 24 horas)

Se você não gostar do que você fez, você pode ou tentar reconstruir o PS1 anterior ou simplesmente sair e voltar para o terminal. (Se você estiver usando um emulador de terminal, basta abrir uma outra aba ou fechar e abrir de novo).

Aqui tem uma referência boa para ler mais sobre essas configurações, mas é bastante extensa e densa, então leia com coragem. Essa sessão e essa sessão são as mais importantes!

Se quiserem, postem seus PS1's aqui embaixo nos comentários! (se mudarem PS2, PS3 ou PS4 mandem também!)

Um beijo!

Você conhece APL?

Patrícia Villela — Tue, 14 Jun 2022 21:43:46 +0000

AVISO! Esse artigo contém exemplos de código. Se você quiser rodá-los, copie e cole as linhas identadas à direita (as linhas identadas à esquerda são os resultados) nesse site: https://tryapl.org

APL é uma linguagem com certeza mais velha que muitos dos desenvolvedores de hoje em dia. Criada em 1966 por Kenneth E. Iverson, é uma das linguagens mais antigas ainda em uso hoje (mais velha que C, a propósito, e do que B também!).
Olhando um código APL, no entanto, você pode ter várias sensações. Uma comum é de que existe algum problema de encoding te impedindo de ler o que está escrito. De qualquer maneira, sua sintaxe não se parece nada com as linguagens de sua época, ou de hoje em dia.
Exemplo de programa em APL:

⍝ média aritmética de uma lista
(+/÷≢)w

Esse é um programa que te retorna a média aritmética de uma lista (w é a lista).
Mas, cadê o loop para somar todos os elementos? E a divisão dessa soma pelo tamanho da lista?

Essa é a magia de APL. Originalmente significando "A Programming Language", nome inspirado no livro que a introduziu, teve seu nome ressignificado para "Array Programming Language", justamente porque suas construções funcionam com dados de qualquer dimensão.

Opa, pera, mas como assim dimensão? Vem comigo!

Mas antes, um porém sobre a interpretação dos símbolos. Ao contrário da maior parte das linguagens de programação, APL é interpretada da direita para a esquerda.

Ou seja, a expressão 10 - 5 - 2, em matemática tradicional, resultaria em 3. Mas em APL

      10 - 7 - 2
5

Porque primeiro foi computado 7 - 2, resultando em 5, e depois 10 - 5, resultando também em 5.

Agora sobre as dimensões.

Dimensões

Vejamos uma variável aqui

      ⍝ definindo uma variável
      a←2
      a
2

(ah, sim, variáveis não recebem seu valor usando =, mas sim usando ←. Você acostuma rápido)

A variável a tem uma dimensão de 0, porque é um valor único. Você pode verificar a dimensão de uma variável usando ⍴⍴ (não são duas letras 'p', mas sim duas letras gregas rô).

      ⍝ número de dimensões de uma variável escalar
      ⍴⍴a
0

Se fosse uma lista, a dimensão seria 1.

      ⍝ número de dimensões de uma lista
      a←1 2 3 4 5
      ⍴⍴a
1

Beleza. Agora vamos somar dois valores escalares, nome de valores de dimensão 0, e duas listas (dimensão 1).

      ⍝ soma entre dois escalares e duas listas
      a←1
      b←2
      a+b
3
      a←1 2 3 4 5
      b←6 7 8 9 10
      a+b
7 9 11 13 15

Note que a sintaxe é a mesma para somar escalares ou listas.
É sobre isso que falo quando digo que as construções de APL são feitas para funcionar com diferentes dimensões. Por isso o exemplo da média aritmética acima não precisa de loop. O loop é intrínseco à linguagem.

Tá, mas e daí?

Claro, é muito legal isso, mas e daí? Por que eu usaria essa linguagem quando eu poderia fazer a mesma coisa com outra?

Há uma série de vantagens em usar APL, principalmente se você precisa lidar com muitos dados (arrays).

Vamos pegar um exemplo do Advent of Code de 2021.
Se você quiser ler todo o problema, accesse aqui

Problema
Há uma lista de leituras de profundidade do oceano e você precisa contar quantas vezes a profundidade aumenta. Ou seja, das leituras, deve-se contar toda vez que uma leitura é maior que a anterior.

Vamos fazer uma solução em Java (sem todo o boilerplate, embora ele exista)

public int contarDescidas(int[] leituras) {
    int leituraAnterior = 0;
    int totalDescidas = 0;
    for(int i = 0; i < leituras.length; i++) {
        if(leituras[i] > leituraAnterior) {
            totalDescidas++;
        }
        leituraAnterior = leituras[i];
    }
    return totalDescidas;
}

Agora em APL

{+/0>2-/⍵}leituras

Isso que eu nem me preocupei em como os dados seriam de fato lidos, o que é toda uma parada complicada no Java, e em APL é isso aqui

leituras←⍎⍤1⊢↑⊃⎕NGET'arquivo'1

Parece complicado mas é muito claro quando se conhece o que cada símbolo faz.

Conclusão

O objetivo desse artigo foi dar um gostinho do que APL é capaz. Eu não tenho nem de longe a expertise de outras pessoas que podem falar mais sobre essa linguagem.

Uma delas é o Rodrigo Girão Serrão. Ele é um desenvolvedor português que está trabalhando para reescrever o livro "Mastering Dyalog APL" (Dyalog APL é uma implementação da linguagem). O canal dele no YouTube é esse aqui
O canal code_report também faz vídeos comparando APL com outras linguagens. Link aqui.

Se você quiser já mergulhar no mundo da APL, pode ler online de maneira gratuita o livro "Mastering Dyalog APL", a versão antiga ou a versão nova (ainda em fase de desenvolvimento).

É isso então. Espero que vocês tenham gostado. Até mais!

DEV Community: Patrícia Villela

Símbolos de APL: "Estrela" e "Log"

Estrela (*)

Log (⍟)

Conclusão

Símbolos de APL: "Vezes" e "Divisão"

Vezes (×)

Divisão (÷)

Conclusão

Símbolos de APL: "Mais" e "Menos"

Monádico vs Diático

Mais (+)

Menos (-)

Conclusão

Símbolos de APL: atribuição

O que é o Advent Of Code?

O que é?

Advento

Então o que é?

Advent Of Code

Como participar?

E você?

Expressões Regulares IV - as três regras da regex I - backtracking

Funcionamento interno das engines de regex

Expressões Regulares III - âncoras, limites de palavras e caracteres de palavras

Âncoras

Limites de palavras

Conclusão

Expressões Regulares II - classes de caracteres

Classes de caracteres

Cautela

Conclusão

Expressões Regulares I - o básico

O começo

Caracteres Literais

Caracteres Especiais

Quantificadores

A regex do começo

Conclusão

Quem é a Lissa?

Quem é Lissa para você?

Quem é Lissa para o mundo?

O quê a Lissa faz atualmente?

Como é ser tão influente nas comunidades tendo 15 anos?

O que fez você se interessar por tecnologia?

O quê são comunidades para você?

Como você conheceu as comunidades de tecnologia?

Como foi fundar a Kotlinautas?

Quais são seus sonhos?

Como customizar o prompt do seu terminal

Variáveis de ambiente que controlam o prompt

Customizando o prompt

Você conhece APL?

Dimensões

Tá, mas e daí?

Conclusão

Estrela (`*`)

Log (`⍟`)

Vezes (`×`)

Divisão (`÷`)

Mais (`+`)

Menos (`-`)