DEV Community: guto

Meet Datomic: the immutable and functional database.

guto — Mon, 15 Apr 2024 23:19:16 +0000

"When you combine two pieces of data you get data. When you combine two machines you get trouble." - Rich Hickey presenting The Functional Database.

Concepts focused on functional programming, mainly on immutability, have been increasingly present in our daily lives, therefore, nothing more fair than getting to know a database whose philosophy is the immutability of data, bringing control of facts in a format completely different from what we are used to.

In this article, we will get to know Datomic, which has this name precisely because it brings data in a format slightly different from the conventional one, seeking to bring data immutability closer to the database level, with a functional approach focused to work well with distributed systems.

What is Datomic?
Architecture
Data structure
How a transaction works?
Conclusion

What is Datomic?

At the beginning of 2012, the Relevance team (later joining Metadata to form Cognitec), together with Rich Hickey, launched Datomic, which they began working on in 2010, with the main motivation being to transfer a substantial part of the power assigned to database servers for application servers, so that the programmer would have more programming power with data within the application logic.

Datomic Cloud was released in early 2018 using Amazon's components:

DynamoDB, EFS, EBS and S3 as storage services;
CloudFormation for deployment;
AWS Cloudwatch for logging, monitoring, and metrics.

Cognitect (the company previously responsible for developing Datomic) was acquired by Nubank in 2020, and Nubank announced in April 2023 that the Datomic binaries are publicly available and free to use (this means that its Pro version is now free to use).

Written in Clojure, Datomic works a little differently from the databases we are used to using, being used to manage data, but not store it. We'll go through more details about its architecture, but in short, it means that Datomic can use several other data storage services to store transactions, even other databases, which can result in a nice combination.

Concept

The main operating concept of Datomic is that the data is immutable as a whole. An interesting analogy for you to imagine and understand how it works a little better is:

Imagine a database that you are used to working with, such as PostgreSQL or MySQL;
Imagine now that you have two tables, a product table, but you also have a log table for these products, storing every modification that was made to the original product table;
When you update an item, this item has its data modified in the product table, but we add its previous value to the log table, highlighting what was done (in our case an update on its value);
For Datomic, there would only be the product "table" (in our case schema), with an additional column, indicating whether that item is true or not, so, when we update the product value, a new line would be added with the new value, however, the old line now has the check column value set to false, after all, it is no longer true at the current time.

This means that past data continues to exist, but there is this representation that indicates whether the value of the product is valid or not. These lines are called facts, so when the word "fact" is mentioned, remember this analogy.

One point to highlight: remember that no matter how much the value of the product has been changed, it remains a fact - no longer valid for the current time, however, it is still a fact that occurred, after all, the product in the past had this value.

Architecture

To better understand how everything works within Datomic, we first need to better understand how its architecture works.

How can I store data?

As previously mentioned, Datomic is not characterized by storing data as a database in the same way as we are used to, being used mainly to "transact and manage data". You can combine Datomic in different ways, such as:

SQL databases (such as PostgreSQL and MySQL);
DynamoDB (if you choose to use Datomic Cloud, the Indexes will be stored in S3, Transaction Log in DynamoDB and Cache in EFS);
Cassandra and Cassandra2;
Dev mode, storing data in memory. How it works is very simple: depending on your choice, a table will be created within your database in order to store all the data, which Datomic will manage.

Peers

Every type of interaction that an application will make with Datomic will be through a Peer, responsible for carrying out a small cache control, assembling and executing queries, bringing indexing data in addition to sending commits. Peers can be used in two main ways, namely:

Peer Library: a library to be added to your dependencies that will always be working with your application, after all, it is through it that you will carry out any type of action with your database;
Peer Server: being used mainly with the Datomic in Cloud format, your application now has only a Client library, responsible for communicating with the Peer Server that will perform direct actions with Datomic, as well as the Peer Library.

Peers work with a given database value for an extended period of time without concern. These values are immutable and provide a stable, consistent view of data for as long as a needs one, functioning as a kind of "snapshot" of the database to allow data to be returned in a more practical way without overloading with multiple queries in real time . This is a marked difference from relational s which require work to be done quickly using a short-lived. You can see more about the description of how Peers work in official documentation.

An important point to highlight is: if you are using the Peer Library, each node of your application, each service will have a Peer running alongside it, therefore, this means that in the process of a distributed system, these multiple Peers will be responsible for sending commits to your database, however, in a distributed system it is extremely important to control data consistency, after all, if I have multiple services sending queries in parallel, how can I control that the data is truthful and correctly passes a race condition? Well, to understand this better, let's understand what Transactor is.

Transactor

The Transactor is responsible for transacting the received commits and storing data within our database. The architecture of an application with Datomic is characterized by having multiple Peers working and sending commits (after all, we will have multiple services), but only a single Transactor, guaranteeing total data consistency. This means that regardless of whether the Transactor is receiving n commits per second, they will all be queued to guarantee total consistency.

The main point of this architectural format comes from understanding that dealing with concurrency in general, allowing multiple data to be stored in parallel in our database, especially in case of a distributed system, could negatively affect the consistency of stored data, being a drastic problem.

Now, we can look in more detail at a diagram that demonstrates how this entire architecture behaves:

Note in the diagram above that the Transactor is responsible for all activities that require direct communication with the data storage service used, in addition to controlling data indexing formats, working with a memcached cluster, and responding to commits. Thus, we can state that Datomic deals with ACID transactions, an acronym that refers to the set of 4 key properties that define a transaction: Atomicity , Consistency, Isolation, and Durability.

Storage Services

"Peers read facts from the Storage Services. The facts the Storage Service returns never change, so Peers do extensive caching. Each Peer's cache represents a partial copy of all the facts in the database. The Peer cache implements a least-recently used policy for discarding data, making it possible to work with databases that won't fit entirely in memory. Once a Peer's working set is cached, there is little or no network traffic for reads." - from Datomic Pro Documentation.

Storage Services can be configured however you like, all you need to do is create a properties file (called transactor.properties) to represent how your Transactor will be created and managed.

So, if you use PostgreSQL, for example, you will have to configure the driver that will be used, the connection url, username and password, and you can also configure values for memory-index-threshold, memory-index-max , object-cache-max, read-concurrency and even write-concurrency, ultimately creating a table named datomic_kvs within your PostgreSQL:



CREATE TABLE datomic_kvs (
  id text NOT NULL,
  rev integer,
  map text,
  val bytea,
  CONSTRAINT pk_id PRIMARY KEY (id)
) WITH (OIDS=FALSE);

Data structure

Well, we've already talked about the architecture of how Datomic as a whole works, so now let's better visualize what the basis of Datomic's data structure is like, starting with Datoms.

Datoms

"A datom is an immutable atomic fact that represents the addition or retraction of a relation between an entity, an attribute, a value, and a transaction."

So basically a datom is a simple fact in log, representing data changes of a relation. We can express a datom as a five-tuple:

an entity id (E)
an attribute (A)
a value for the attribute (V)
a transaction id (Tx)
a boolean (Op) indicating whether the datom is being added or retracted

All of these are from Datomic Cloud documentation. Look at the example below:

E	42
A	:user/favorite-color
V	:blue
Tx	1234
Op	true

Entities

"A Datomic entity provides a lazy, associative view of all the information that can be reached from a Datomic entity id."

Looking into an Entity we can visualize as a table:

E	A	V	Tx	Op
42	:user/favorite-color	:blue	1234	true
42	:user/first-name	"John"	1234	true
42	:user/last-name	"Doe"	1234	true
42	:user/favorite-color	:green	4567	true
42	:user/favorite-color	:blue	4567	false

The Transaction Id can be visualized as a point of the time which represents that data. In the example above we have 1234 and 4567. Look at 1234... In the first row, the :user/favorite-colour attribute has the value :blue, with op as true. But, in the future, at 4567 now the attribute has the op set to false for the attribute with the value :blue (now :green is set for true).

For us, we haven't changed manually the Op. Datomic automatically made this when we updated the value for :user/favorite-color. That means: Datomic automatically manage our data and set or update values, and we have the exactly point in time which the :user/favorite-color have been changed.

Schemas

As the documentation says: Attributes are defined using the same data model used for application data. That is, attributes are themselves defined by entities with associated attributes.

Well, for defining a new attribute we need to define:

:db/ident, a name that is unique within the database
:db/cardinality, specifying whether entities can have one or a set of values for the attribute
:db/valueType, the type allowed for an attribute's value
:db/doc (optional), the attribute's description/documentation

Look, all of these :db/ident, :db/cardinality and etc are only simple entities which pointer to each other. They are automatically generated by Datomic in the initial stage. This means: they have a default entity id.

How a transaction works?

"Every transaction in Datomic is its own entity, making it easy to add facts about why a transaction was added (or who added it, or from where, etc.)"

We have "two options" for transactions: add or retraction. Every transaction returns the transaction id and the database state before and after the transaction. The forms can be:



[:db/add entity-id attribute value]
[:db/retract entity-id attribute value]

How we saw before: every transaction occur in a queued mode.

If a transaction completes successfully, data is committed to the database and we have a transaction report returned as a map with the following keys:

key	usage
:db-before	database value before the transaction
:db-after	database value after the transaction
:tx-data	datoms produced by the transaction
:tempids	map from temporary ids to assigned ids

The database value is like a "snapshot" from the database, as we saw before.

Let's see an example of how :db/add works. Look at the example below:



;; We have this schema
{:internal/id ...
 :internal/value 0
 :internal/key " "}

;; Making a simple transaction
[[:db/add id :internal/value 1]]
;; This will update the value...

;; But, we can perform multiple
;; transactions, look:
[[:db/add id :internal/value 1]
 [:db/add id :internal/key "another"]]
;; It will work fine.

;; But, when we perform something like:
[[:db/add id :internal/value 1]
 [:db/add id :internal/value 2]]
;; We will have a conflict

The conflict occur when we have a change in the same entity with the same attribute. That's make sense, because we can't have a fact updating multiple times in the same time lapse.

A cool fact: if we perform a multiple transaction they occur in parallel (with multiple processing). This is secure because as we saw before, the same attribute can't be updated in the same transaction.

Conclusion

This article and the beginning of this series of articles aims to introduce Datomic and present its various possibilities and advantages for general use. It is important to highlight that the official Datomic documentation is excellent, therefore, for further in-depth research it is extremely important that you use it! And of course, if you want to take your first steps with Datomic, feel free to use Getting Started from the official documentation, but if you want a repository with the codes used, I've made a repository available on my GitHub (don't forget to give a star)!

Conhecendo o ecossistema Crystal: ferramentas e projetos

guto — Mon, 16 Oct 2023 23:26:52 +0000

Bem, se você abriu esse artigo, então, tenho certeza que está interessado em entender um pouco mais sobre o ecossistema de Crystal. Antes de mais nada, vamos primeiramente introduzir o que é Crystal e onde se aplica.

Índice

O que é Crystal?
Ruby e Crystal
Integração nativa com LibC
Ferramentas
1. Language Server Protocol (LSP)
2. Read-Eval-Print Loop (REPL)
3. Code style linter
4. Debugger
5. Gerenciador de dependências
6. Livro
7. Documentação
8. Patterns
Frameworks
1. Kemal
2. Amber
3. Lucky
4. Marten
Projetos com Crystal
Finalização

O que é Crystal?

Crystal é uma linguagem de programação de código aberto, com sintaxe inspirada no Ruby, que visa a produtividade e o desempenho. Ele tem uma sintaxe elegante e uma tipagem estática, mas sem a necessidade de declarar tipos de variáveis. O Crystal é compilado para código nativo, e não para bytecode, e usa LLVM para gerar o código binário.

A aplicabilidade de Crystal é vasta, podendo ser visto de diferentes formas, mas, consigo afirmar que a ênfase de aplicabilidade ocorre para aplicações web, na qual consegue se destacar em pontos específicos exatamente por ser uma linguagem de programação compilada.

O principal motivo para o surgimento de Crystal foi para resolver alguns problemas bem específicos que Ruby possuia, porém, seriam solucionados deixando de lado a dinamicidade que Ruby proporcionava para abrir espaço para uma linguagem de programação totalmente nova, com a possibilidade de inferência de tipos, sendo compilada. Assim, em 2011 surge o projeto de uma nova linguagem de programação, criada por Ary Borenszweig, Juan Wajnerman e Brian Cardiff, contando hoje com mais de 450 colaboradores do mundo todo, tendo seu código fonte disponibilizado no repositório oficial do GitHub.

Ruby e Crystal

Como citado anteriormente, Ruby por sua vez possui uma sintaxe muito elegante, na qual Crystal se inspirou em sua maior parte exatamente pelo contexto de desenvolvimento da época, desejando uma linguagem de programação elegante na sintaxe como Ruby, veloz como C, podendo ainda realizar otimizações nativas com interoperabilidade utilizando a LibC e o melhor: sem escrever uma linha de código em C. Parece mágica não é? Bem, é apenas Crystal!

Uma analogia para entender melhor a compatibilidade de ambas as linguagens de programação que gosto de fazer é: imagine que você hoje é dono de uma empresa que possui N desenvolvedores Ruby, que consequentemente são a maioria dentro da empresa. Em um belo dia você em uma conversa com seus arquitetos de software decidem que uma linguagem compilada é necessária em apenas alguns serviços que estão funcionando hoje. Ao invés de simplesmente reescrever todo o código em alguma outra linguagem compilada, você pode reaproveitar toda a base de código para utilizar e compilar em Crystal, assim, a curva de aprendizado para seus desenvolvedores Ruby será praticamente nula, afinal, apenas alguns pontos específicos requerem maior cuidado ao se trabalhar com Crystal, como por exemplo a verificação de tipos, que pode ser um pouco estranho no início, mas, garanto que com o passar do tempo será mais prática a manutenção de seu código.

Entenda que Crystal não veio para substituir o Ruby, mas, para que ambos possam ser utilizados em conjunto, visando um melhor aproveitamento de código, melhor eficiência e melhor ambiente de desenvolvimento. O exemplo que deixarei abaixo demonstra a diferença de dois códigos que fazem a mesma coisa, porém, Crystal possui uma peculiaridade específica que vou retratar logo abaixo.

def soma(a, b)
  a + b
end

print "Digite o primeiro número inteiro: "
a = gets.chomp.to_i
print "Digite o segundo número inteiro: "
b = gets.chomp.to_i

puts "A soma dos números é #{soma(a, b)}"

O código acima é bem simples: pedimos para o usuário informar dois números, a e b respectivamente, na qual chomp remove o enter (\n ou \r) e o to_i converte o valor para inteiro. Agora, em Crystal precisamos apenas adicionar uma validação bem simples:

def soma(a, b)
  a + b
end

print "Digite o primeiro número inteiro: "
a = gets
print "Digite o segundo número inteiro: "
b = gets

# É necessário validar se o valor é nil!
if a.nil? || b.nil?
  puts "Você deve digitar dois números inteiros."
  exit
end

puts "A soma dos números é #{soma(a.chomp.to_i, b.chomp.to_i)}"

A validação é necessária para não enviarmos um valor nulo para o método chomp, afinal, ele está esperando receber uma String e sem a validação estaremos enviando um String | Nil, não validando com o tipo esperado. Nesse momento você deve estar pensando: mas, os tipos enviados foram validados em tempo de compilação? Isto é, a inferência dos tipos foi feita sem eu precisar falar nada? Bem, a resposta é sim, o compilador automaticamente adivinhou de quais tipos se tratavam.

Certo, agora você deve perguntar: nossa mas eu também consigo inferir os tipos manualmente? Como por exemplo na função soma, informando os tipos dos parâmetros que espero receber, além do tipo do retorno? A resposta é sim, e neste caso ficaria algo como o exemplo abaixo:

def soma(a : Int32, b : Int32) : Int32
  a + b
end

Interessante, certo?

O principal ponto é dar nas mãos do desenvolvedor a possibilidade de nivelar exatamente o que um método deve ter e/ou deve retornar.

Integração nativa com LibC

Se você quer utilizar ferramentas da LibC, mas, sem a necessidade de escrever código em C, então Crystal pode te ajudar com isso. Com bindings nativas você pode utilizar bibliotecas externas, incluindo a LibC, para utilizar ferramentas que seriam possíveis apenas escrevendo código nativo em C.

Para entender um pouco melhor sobre o funcionamento, recomendo seguir a documentação oficial, porém, deixarei um exemplo abaixo,

lib C
  # Em C: double cos(double x)
  fun cos(value : Float64) : Float64
end

O exemplo acima demonstra o uso da função cos

Ferramentas

Como todo desenvolvedor, nada melhor do que saber como preparar seu ambiente de desenvolvimento com Crystal, não é mesmo? Bem, vamos então navegar por algumas tecnologias que vão te ajudar nessa jornada.

Language Server Protocol (LSP)

Como todo bom desenvolvedor, sabemos que um LSP pode nos auxiliar muito durante o desenvolvimento de software, por isso, o LSP que estarei recomendando para uso com Crystal é o Crystalline, na qual você poderá configurar de forma simples na maioria dos editores de código que esteja utilizando.

Basicamente o Crystalline vai disponibilizar um executável simples, sendo totalmente escrito em Crystal. Você pode seguir os passos deixados no próprio repositório para configurar seu ambiente, porém, gostaria de dizer que um dos guias de configuração que contribuí foi para o Emacs, utilizando o emacs-lsp.

Minhas recomendações para editores de código são bem pessoais, porém, recomendaria alguns como Visual Studio Code, Sublime Text, Vim e Emacs.

Read-Eval-Print Loop (REPL)

Desenvolver ao lado de um REPL é uma experiência simplesmente magnífica e recomendo sempre que possível, por isso, Crystal não fica de fora no mundo de REPLs e possui o icr como REPL oficial, vindo hoje já embutido no próprio Crystal, podendo ser acessado com o comando crystal i!

Basicamente a funcionalidade principal do REPL é ser seu companheiro durante o desenvolvimento, possibilitando a execução de trechos do código de forma isolada sem muitos problemas.

Code style linter

Mais importante do que escrever código para si mesmo é escrever código para outras pessoas, por isso, sempre que possível é recomendado escrever códigos de acordo com as convenções de cada linguagem de programação. Dessa forma, Crystal possui uma convenção de estilo de código incrível, logo, nada mais justo do que uma ferramenta que te ajude no processo de escrita.

Assim surge o projeto Ameba, sendo um linter para validar seu código e verificar se está adequado de acordo com as convenções apresentadas oficialmente.

Debugger

Nada melhor do que poder rodar seu código passo por passo para validar problemas e rotinas, não é? Pois bem, o projeto debug surge com objetivo de ser um debugger completo para seu desenvolvimento, sendo escrito completamente em Crystal.

Gerenciador de dependências

Dependências podem ser definidas como um conjunto de pacotes/bibliotecas que são necessárias para a execução de determinada aplicação. Gerenciar dependências de forma elegante é algo que Crystal não decepciona utilizando o projeto Shards.

Basicamente existe um arquivo chamado shard.yml, utilizado para definir de maneira simples pontos como nome do projeto, autores, dependências, versão atual e licença em que determinado projeto é distribuído.

Livro

Um livro sobre a linguagem é necessário, não apenas para ser utilizado como referência, mas, para ser utilizado no processo de aprendizado do leitor.

Assim surge o projeto crystal-book, sendo um livro completo com referências da documentação oficial.

Documentação

A documentação oficial é necessária para qualquer tecnologia, assim, Crystal possui dois tipos de documentações que podem ser encontradas, sendo elas:

A segunda referência geralmente é utilizada para um detalhamento maior dos métodos e funcionalidades nativas que Crystal proporciona.

Patterns

A definição de patterns e padrões de código é necessária, por isso, existe um repositório com exemplos didáticos de implementações com Crystal utilizando os patterns GOF (Gang of Four), chamado crystal-patterns.

Frameworks

Atualmente, Crystal conta com diversos frameworks para diversos propósitos, porém, irei citar os mais conhecidos para desenvolvimento de aplicações web no geral.

Kemal

Sendo um dos frameworks mais conhecidos, Kemal se destaca por ser inspirado no estilo de outro framework já existente para Ruby, o Sinatra, sendo utilizado para ser uma solução simples, com tratamento de rotas elegante, possibilitando um middleware que pode ser ampliado.

Sua implementação ocorre de forma simples, sendo bem minimalista, assim, uma comparação deixada no site oficial do Kemal compara a quantidade de requisições por segundo de uma aplicação com Kemal comparada com uma aplicação Ruby com Sinatra: enquanto o Sinatra conseguiu chegar em 5268 requisições por segundo, Kemal conseguiu atingir invejadas 122697 requisições por segundo (magnífico, não é?).

Amber

Com uma proposta um pouco diferente do Kemal, porém, levando tanto o Kemal quanto Rails e Phoenix como inspiração, temos o Amber, um framework para aplicações robustas, possuindo templates de renderização HTML prontos, possibilitando um desenvolvimento mais produtivo.

O framework conta com a possibilidade de uso de três ORMs distintos, sendo eles Jennifer, Granite e Crecto.

Lucky

Sendo um framework inspirado principalmente no Rails, o Lucky é um framework que está no coração de grande parte dos desenvolvedores que alguma vez já trabalharam com Crystal, trazendo infinitas possibilidades, sendo extremamente rápido e produtivo!

O repositório oficial está disponível no GitHub, tendo consigo também um artigo interessante falando sobre o uso do Lucky na perspectiva de um desenvolvedor que já trabalhou alguma vez com Rails. O nome do artigo é Ruby on Rails to Lucky on Crystal: Blazing fast, fewer bugs, and even more fun e recomendo a leitura.

Marten

Um framework novo, porém com propostas interessantes, trazendo conceitos novos para o mundo de desenvolvimento com Crystal, ampliando a simplicidade e produtividade dentro do seu código. Este é o Marten, tendo seu repositório oficial publicado no GitHub já está tomando espaço e crescendo cada vez mais como um dos frameworks para Crystal que tende a melhorar ainda mais.

Já ganhou um espaço especial no meu coração e tenho certeza que você vai adorar utilizar o Marten em seu cotidiano como desenvolvedor.

Projetos com Crystal

Bem, como foi possível observar, a aplicabilidade de Crystal é bem vasta e existem diversas ferramentas para te auxiliar durante todo o processo, mas, quais projetos reais já existem e levam como base o uso de Crystal? Bem, vamos passar citando alguns maneiros se você talvez esteja pensando em começar a contribuir...

Awesome Crystal: conjunto de repositórios, bibliotecas e ferramentas para uso no desenvolvimento com Crystal, trazendo tudo de melhor que o ecossistema pode te proporcionar
Invidious: um projeto que tem crescido muito e traz consigo o objetivo de ser uma alternativa para o front-end do YouTube, reduzindo a quantidade de JavaScript a ser renderizado, sendo distribuído sob licença AGPL 3.0
Slang: uma linguagem de template inspirada no Slim para construção de páginas web sem a necessidade de escrever HTML puro
Immutable: uma implementação completa de uma coleção de estruturas de dados imutáveis, thread-safe e persistente, possibilitando uma melhor segurança no processamento e acesso de memória
Hetzner k3s: um CLI completo para gerenciamento de cluster Kubernetes na Hetzner Cloud utilizando a distribuição k3s
Hackacrow: um CLI completo para validação de entradas e saídas de comandos, sendo útil principalmente para validações de respostas em hackathons
Crystal ZSH: um plugin completo para utilizar junto do oh-my-zsh, permitindo uma integração magnífica com seu terminal durante o desenvolvimento com Crystal
Editor Plugins: sendo uma área específica de outro repositório (awesome-crystal nesse caso) conta com plugins interessantes para diferentes editores de código, por isso, recomendo conhecer

Existem diversos outros projetos com Crystal, porém, acredito que vale a pena conferir o primeiro repositório citado anteriormente para conhecer outros projetos que utilizam Crystal.

Finalização

O intuito desse artigo foi apresentar um pouco mais sobre a proposta que Crystal traz no mundo de desenvolvimento de software, citando ferramentas e projetos que podem fazer parte do seu cotidiano de desenvolvimento.

Se você quer aprender um pouco mais sobre Crystal com um conteúdo totalmente gratuito, em português, escrito com muito amor e carinho, recomendo a leitura do crystal4noobs, um conteúdo parte do projeto 4noobs da He4rt Devs, trazendo conteúdo de qualidade para todos de forma gratuita.

Agradeço imensamente se você chegou até aqui e espero que tenha gostado da leitura. Não se esqueça de deixar sua estrelinha os repositórios apresentados. Espero que esse artigo possa crystalizar ainda mais sua rotina de desenvolvimento. Meu muito obrigado e até a próxima!

Da comunidade para a comunidade 💜💛

How to write a CRUD CLI using Elixir and ScyllaDB

guto — Mon, 18 Sep 2023 21:30:00 +0000

If you know high traffic applications for communication, applications that need low latency and good fault tolerance, you have most likely already come across the names Elixir (as a programming language) and ScyllaDB (being a database NoSQL aimed at low latency). The objective of both is very similar: to work with applications that generally require greater care for stability.

ScyllaDB is recognized worldwide as an extremely fast database, being based on Apache Cassandra, bringing several improvements for low latency. Furthermore, ScyllaDB is completely free, open source, and is distributed under the GNU AGPL license.

Elixir, on the other hand, is a programming language known for dealing very well with the applicability of concepts such as concurrency and fault tolerance and this is thanks to the Erlang ecosystem, which in this case, Elixir makes use of the virtual machine called BEAM, designed specifically to work with high-volume messaging applications.

The purpose of this article is to offer an introduction to how you can create your first application using both, opening doors and possibilities for your future with development with these two incredible technologies.

Starting the project
- Installing Elixir
- Installing ScyllaDB
- Starting our project
Configuring the project
- Defining dependencies
- Configuring .env
- Defining our connection module
Implementing actions with the database
Commands
- Add
- List
- Delete
- Stress
Implementing user interaction
Running our application
Conclusion

Starting the project

Beforehand we need to install both Elixir and ScyllaDB. I won't go into too much detail about the installation because this makes the article simpler. So let's start with installing Elixir.

Installing Elixir

To install Elixir in general, there are two main methods: installing directly from your package manager or using a version manager for programming languages. In my case I will be using asdf as responsible for managing my Elixir versions. If you want to install Elixir using your package manager, click here to receive more information.

To install asdf you can check by clicking here. As a preference, I always choose to install with "Bash & Git" or "Zsh & Git". Once installed, we will prepare the installation to receive the latest version of Erlang and Elixir in our project. To install Erlang:

$ asdf plugin add erlang https://github.com/asdf-vm/asdf-erlang.git

$ asdf install erlang latest

$ asdf global erlang latest

Did you have any problems with the installation? Access the official guide.

To install Elixir:

$ asdf plugin-add elixir https://github.com/asdf-vm/asdf-elixir.git

$ asdf install elixir latest

$ asdf global elixir latest

Did you have any problems with the installation? Access the official guide.

Well, now that we have both installed we can test to see if everything is ok by typing elixir -v in our terminal emulator and we will get a response similar to:

Erlang/OTP 25 [erts-13.2.2.2] [source] [64-bit]

Elixir 1.13.4 (compiled with Erlang/OTP 23)

These are my installed versions for Erlang and Elixir. If you want to install the same versions as me on your machine, just modify the asdf install command, replacing latest with the version number and then set it to asdf global elixir 1.13.4 in this case.

Installing ScyllaDB

There are several ways to use ScyllaDB, which you can use with ScyllaDB Cloud, with ScyllaDB installed on your machine or the way I will use it: with Docker containers.

If you don't already have Docker installed, I recommend accessing the [installation] guide (https://docs.docker.com/engine/install/). If you want to use ScyllaDB Cloud or ScyllaDB installed on your machine, there's no problem, just be careful when placing the node links when initializing and configuring the project, but when we get to this part I'll explain it better.

Well, continuing... To run our container with ScyllaDB in Docker we will use the following command:

$ docker run --name some-scylla -p 9042:9042 -d scylladb/scylla

The -p option indicates that we want to bind port 9042 of the container with port 9042 of our machine, allowing our container to now be accessed directly on our localhost:9042.

For test the connection, after executing the command, wait a few seconds for everything to start correctly in the container and then type:

$ docker exec -it some-scylla cqlsh

So you will see a response similar to:

Connected to at 172.17.0.2:9042.
[cqlsh 5.0.1 | Cassandra 3.0.8 | CQL spec 3.3.1 | Native protocol v4]
Use HELP for help.
cqlsh>

This is our console where we can execute commands to interact with ScyllaDB. By default, the language used is CQL (Cassandra Query Language), very similar to the standard database SQL that you probably have already had contact.

Well, let's run a simple command to describe all the keyspaces we have in our container. keyspaces could be defined with a simple analogy: keyspace is basically the same as database when you use a relational database like MySQL or PostgreSQL for example (the definition goes a little beyond that, but I won't go into it very).

To describe your keyspaces run:

cqlsh> DESCRIBE KEYSPACES;

And you should see a response similar to:

system_schema system_traces system_distributed

We haven't created any keyspace yet, right? Well, let's create our keyspace, which in this case is for a media_player, with the command:

cqlsh> CREATE KEYSPACE media_player
     WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '3'}
     AND durable_writes = true;

And let's create the table:

cqlsh> CREATE TABLE media_player.songs (
     id uuid,
     titletext,
     album text,
     artist text,
     created_at timestamp,
     PRIMARY KEY (id, created_at)
);

Starting our project

For start a new project, run the command:

$ mix new media_player

Mix is much more than a dependency manager for Elixir, after all, with it we can run and manage our entire project. By default, Mix is already installed together with Elixir.

And a project will be created with the structure:

.
├── README.md
├── lib
│   └── media_player.ex
├── mix.exs

Well, now that we have our project initialized, we can start playing, so open your favorite code editor and let's go.

Configuring the project

At this point we will configure our project in Elixir to install and use all the tools necessary to build our CLI, in addition to defining the first settings.

Defining dependencies

After opening your code editor, notice that there is a file named mix.exs. This file is responsible for defining several attributes about our project, including the dependencies that will be used during its development.

Going down the page a little you will see an area that starts with defp deps do... Exactly in this part we will modify and insert the following dependencies:

# Run "mix help deps" to learn about dependencies.
defp deps
  [
    {:dotenv, "~> 3.0"},
    {:decimal, "~> 1.0"},
    {:xandra, "~> 0.14"},
    {:elixir_uuid, "~> 1.2"}
  ]
end

Dotenv: A port of dotenv to Elixir.
Decimal: Arbitrary precision decimal arithmetic.
Xandra: Fast, simple, and robust Cassandra/ScyllaDB driver for Elixir.
Elixir UUID: UUID generator and utilities for Elixir. See RFC 4122.

Well, now that we have our dependencies defined we can run it in our terminal emulator:

$ mix deps.get

The command above will install all dependencies that were defined in our mix.exs.

Great! Now we can configure our environment variables for the project within .env.

Configuring .env

Well, let's now create a file called .env at the root of our project (that's right, at the same level as our mix.exs). It will be responsible for defining the first configurations of our project, including the environment variables that will be used to connect our cluster.

When creating the file and opening it in the code editor, we will define:

SCYLLADB_USERNAME=
SCYLLADB_PASSWORD=
SCYLLADB_NODE=
SCYLLADB_KEYSPACE=
SCYLLADB_TABLE=

SCYLLADB_USERNAME: username configured to connect to ScyllaDB.
SCYLLADB_PASSWORD: password configured for the user.
SCYLLADB_NODE: complete url to connect to our node, you can enter just one url (such as localhost:9042 for example) or define the complete nodes generated separated by a comma (such as scylla-node1.com,scylla- node-2.com,scylla-node-3.com).
SCYLLADB_KEYSPACE: the keyspace generated for our application.
SCYLLADB_TABLE: table that will be used for the respective keyspace.

This way our .env should look like:

SCYLLADB_USERNAME=scylla
SCYLLADB_PASSWORD=scylla
SCYLLADB_NODE=localhost:9042
SCYLLADB_KEYSPACE=media_player
SCYLLADB_TABLE=songs

Perfect! Now that our connection files are ready, we can start structuring the project, shall we?

Defining our connection module

It is elegant and interesting to separate the connection module in a separate area of our project, allowing for more practical maintenance and attractive organization, so let's create two directories with the path lib/media_player/config. This directory will be responsible for storing two main configuration files: the file for connecting to the Cluster and the file for defining the keyspace and table.

Well, let's create two files inside the lib/media_player/config directory, called connection.ex and database.ex. This way our directory structure will now be:

.
├── README.md
├── lib
│   ├── media_player
│   │   └── config
│   │   ├── connection.ex
│   │   └── database.ex
│   └── media_player.ex
├── mix.exs

Yes, I omitted the deps directory because it contains the dependencies, that is, nothing that we are going to modify manually, don't worry, in addition to omitting the test directory because it will contain the tests that can be implemented, but, no let's implement it for now.

Well, now we can define the connection to our cluster, starting with the database.ex file.

defmodule MediaPlayer.Config.Database do
  import Dotenv

  load()

  def start_link do
    options = [
      username: System.get_env("SCYLLADB_USERNAME"),
      password: System.get_env("SCYLLADB_PASSWORD")
    ]

    {:ok, cluster} =
      Xandra.Cluster.start_link(
        sync_connect: :infinity,
        authentication: {Xandra.Authenticator.Password, options},
        nodes:
          System.get_env("SCYLLADB_NODE")
          |> String.split(",")
      )

    cluster
  end
end

In this file we:

We import the Dotenv library to manage the variables defined in our .env file;
We load the variables with the load() function that comes from the Dotenv library;
We created a function named start_link that will be responsible for starting the connection link with our cluster;
In the function we define the username and password receiving these values from the .env file;
We initialize the cluster with the function coming from Xandra with the name Xandra.Cluster.start_link, responsible for starting a connection link with the cluster
- In this function we define that sync_connect is with value :infinity! This means that it will try to make the connection with an infinite expected response time (that is, the module will wait as long as necessary to make the complete connection of all nodes). To read more about click here;
- We define that we are going to perform authentication and pass options (which was defined previously) as a parameter;
- We define our nodes by loading from our .env file and performing a division with the commas found, distributing them in a list (nodes expects a list of urls to make the connection, which is why the split is necessary to create this list) . If you use ScyllaDB Cloud, this is what will make everything work perfectly;
We return the cluster with the connection ready.

Perfect! Our connection file is ready. Now let's configure a simple area that will only be responsible for returning the keyspace and the table, called connection.ex:

defmodule MediaPlayer.Config.Connection do
  import Dotenv

  load()

  def keyspace() do
    System.get_env("SCYLLADB_KEYSPACE")
  end

  def table() do
    System.get_env("SCYLLADB_TABLE")
  end
end

Basically the only functionality of this module is to have two functions to return the keyspace and the table that we will be using, without the need to always use the .env library!

Implementing actions with the database

Well, now is another important point: as our project will have commands, therefore, it would be interesting to create a specific module to handle these commands, right? Perfect! However, before that, what do you think about creating a module to execute queries in the database, so we can centralize where the queries will be executed.

Well, this is the time to create a file in lib/media_player with the name actions.ex. So our directory structure will look like this:

.
├── README.md
├── lib
│   ├── media_player
│   │   ├── actions.ex
│   │   └── config
│   │   ├── connection.ex
│   │   └── database.ex
│   └── media_player.ex
├── mix.exs

Wonder! With the file created we can now create two specific functions, but why two? Simple: the Xandra.Cluster.execute function has two variations, the first with two parameters (the cluster and the query to be executed) and the second with three parameters (the cluster, the query to be executed and the parameters, being a list that is mainly used to prepare our query).

Let's go then, our module should look like this:

defmodule MediaPlayer.Actions do
  def cluster, do: MediaPlayer.Config.Database.start_link()

  def run_query(query) do
    case Xandra.Cluster.execute(cluster(), query) do
      {:ok, result} ->
        result

      {:error, error} ->
        IO.inspect(error)
    end
  end

  def run_query(query, params) do
    prepared = Xandra.Cluster.prepare!(cluster(), query)

    case Xandra.Cluster.execute(cluster(), prepared, params) do
      {:ok, result} ->
        result

      {:error, error} ->
        IO.inspect(error)
    end
  end
end

In this file we:

We define a local cluster function that does nothing more than initialize and return the connection link to the cluster;
We define a function run_query/1 that takes just one parameter (being just the query, after all, the cluster is already a local function and we know that we will always execute actions on it);
- We tried to perform the query with the function Xandra.Cluster.execute;
- If the return is :ok, it means that everything went well, then we return the complete result (a complete map of the query);
- If the return is :error it means that an error occurred when performing the query, then we inspect the specific error;

An important detail is about the assignment made with {:ok, result} and {:error, error}, since in Elixir everything has a return, always being a map starting with an atom validating the return type that was given (I recommend seeing more about atoms), so we bind values with a map!

We define a function run_query/2 that takes two parameters (only the query and the parameters to be executed):
- We tried to perform the query with the Xandra.Cluster.execute function:
- If the return is :ok, it means that everything went well, then we return the complete result (a complete map of the query);
- If the return is :error it means that an error occurred when performing the query, then we inspect the specific error;

If you want to see more about how the Xandra.Cluster.execute function works, click here.

A detail that you may not have noticed: both functions have the same name, however, they differ in terms of the number of parameters! This makes the magic happen with Elixir. Functions are defined along with the number of parameters they expect to receive, so I put the name of the function followed by a slash "/" with the number of parameters. If you want to know more about it, click here to better understand how Elixir works with Pattern Matching.

Commands

Well, now is the long-awaited moment: adding the functions responsible for executing commands in our application! To do this, we will create a file in lib/media_player with the name commands.ex. This way our directory structure will be equal to:

.
├── README.md
├── lib
│   ├── media_player
│   │   ├── actions.ex
│   │   ├── commands.ex
│   │   └── config
│   │   ├── connection.ex
│   │   └── database.ex
│   └── media_player.ex
├── mix.exs

Let's start by creating the basis of our entire module:

defmodule MediaPlayer.Commands do
  alias MediaPlayer.Actions, as: Actions
  alias MediaPlayer.Config.Connection, as: Connection

  defp keyspace, do: Connection.keyspace()
  defp table, do: Connection.table()
end

Basically above we defined that we will have:

The alias Actions to refer to the MediaPlayer.Actions module;
The alias Connection to refer to the MediaPlayer.Config.Connection module;
The private function keyspace that returns the keyspace value that we will use;
The private function table that returns the table value that we will use;

Well, now we can start implementing the commands, shall we?

Add

Well, this command will be used to add songs to our database. Therefore, we will separate it into two main functions, namely add and add_from, which receive four parameters to be executed. The add function will only collect the data to be inserted:

defmodule MediaPlayer.Commands do
  alias MediaPlayer.Actions, as: Actions
  alias MediaPlayer.Config.Connection, as: Connection

  defp keyspace, do: Connection.keyspace()
  defp table, do: Connection.table()

  def add_from(title, album, artist, created) do
    query =
      "INSERT INTO #{keyspace()}.#{table()} (id, title, album, artist, created_at) VALUES (?, ?, ?, ?, ?);"

    {:ok, created, _} = DateTime.from_iso8601(created <> "T00:00:00Z")

    Actions.run_query(query, [UUID.uuid4(), title, album, artist, created])

    IO.puts("Song added!")
  end

  def add() do
    title = IO.gets("Enter the title of the song: ") |> String.trim()
    album = IO.gets("Enter the album of the song: ") |> String.trim()
    artist = IO.gets("Enter the artist of the song: ") |> String.trim()

    created =
      IO.gets("Enter the date the song was created (YYYY-MM-DD): ")
      |> String.trim()

    add_from(title, album, artist, created)
  end
end

Well, both functions are very specific, so let’s give an example of each one:

The add function will:
- Collect the song title;
- Collect the music album;
- Collect the song artist;
- Collect the creation date of the song;
- Invoke the add_from function passing the collected values as parameters;
The add_from/4 function will:
- Receive four parameters;
- Create the query that will be executed;
- Convert the date format to ensure bind compatibility with Xandra;
- Call the function to perform the query passing two parameters: the query and additional options in a list format (as explained previously)
- Then just show the message on the screen when the song is inserted!

Another point: the "|>" pipe in Elixir works like the "|" pipe of Unix shells, being used to pass the return of a function as the first parameter of the next. Read more about pipes here.

Well, now we have the function responsible for adding a created song! Let's go next time?

List

Now let's create a function responsible for listing all the songs we have added. Therefore, we will have as a result:

  def list
    query = "SELECT id, title, album, artist, created_at FROM #{keyspace()}.#{table()};"

    Actions.run_query(query)
    |> Enum.each(fn %{
                      "id" => id,
                      "title" => title,
                      "album" => album,
                      "artist" => artist,
                      "created_at" => created_at
                    } ->
      IO.puts(
        "ID: #{id} | Title: #{title} | Album: #{album} | Artist: #{artist} | Created At: #{created_at}"
      )
    end)
  end

The list function does not receive any parameters, after all, it will print the songs that were added to the screen, like this:

We define a query by selecting id, title, album, artist, created_at and to define the keyspace and table remember that we already have two functions that return these values!
We tried to perform a simple query (which has no additional options besides query) and its return we passed to an Enum.each (similar to a foreach in other programming languages);
- Within each we pass an anonymous function responsible for handling the return, which in this case expects to receive a map with the respective fields that were selected;
- We print specific values;
In the end this will be our return;

An important detail: in this case, run_query would return more than one value if we had multiple rows inserted, right? Well, run_query returns a complete list of maps with their respective values, so we use Enum.each to treat each index in the list we have.

Delete

Well, the delete command is a little more complex because we need the user to type the index he wants to delete, validating it against the list of indexes that were returned! Therefore, the implemented function would result in something like:

  def delete() do
    query = "SELECT id, title, album, artist, created_at FROM #{keyspace()}.#{table()};"

    songs =
      Actions.run_query(query)
      |> Enum.with_index(fn %{
                              "id" => id,
                              "title" => title,
                              "album" => album,
                              "artist" => artist,
                              "created_at" => created_at
                            },
                            index ->
        IO.puts(
          "Index: #{index + 1} | Title: #{title} | Album: #{album} | Artist: #{artist} | Created At: #{created_at}"
        )

        %{id: id, title: title, album: album, artist: artist, created_at: created_at}
      end)

    {input, _} = IO.gets("Enter the index of the song you want to delete: ") |> Integer.parse()

    case Enum.at(songs, input - 1) do
      %{} = song ->
        query = "DELETE FROM #{keyspace()}.#{table()} WHERE id = ? AND created_at = ?;"

        Actions.run_query(query, [song.id, song.created_at])

        IO.puts("Song deleted!")

      nil ->
        IO.puts("Invalid index.")
    end
  end

Well, basically we have in this function:

Definition of the query returning all added songs;
Listing similar to the previously implemented list function;
- We try to perform the query in Actions.run_query and pass it to Enum.with_index to have the indexes;
- This time instead of presenting the id of the song we present a manual index (instead of starting with 0 it starts with 1, hence index + 1), in which the user will type (more practical to type a number integer than a UUID isn't it?);
- We print the values;
- We added the complete list in songs;
We wait for the user to make an entry stating which index he wants to delete and we parse the entry that will be saved in input;
We check whether the index entered is present in songs;
- If you are:
- We create the query;
- We tried to perform the query in Actions.run_query and added the list of options to bind to the query as a parameter;
- We print the message informing that the song has been deleted;
- If not:
- We print that the index is invalid

This way we finish our function to delete a song!

Stress

Great! The commands that necessarily manipulate user input are finished! Now let's create an additional command that will be responsible for performing a stress test on our database. We will define two functions, namely the stress function that will initialize the command, in addition to a private function with the name generate_stress_query that receives a parameter with the name some_id, with the index being inserted.

First of all, we must add the following section at the beginning of our module:

defmodule MediaPlayer.Commands do
  use Task
  ...

With Task we can perform asynchronous calls with better practicality and performance. To read more click here.

Thus, implementing our functions:

  defp generate_stress_query(some_id) do
    current_date = Date.to_string(Date.utc_today())

    "INSERT INTO #{keyspace()}.#{table()} (
      id, title, album, artist, created_at
    ) VALUES (
      #{UUID.uuid4()},
      'Test Song #{some_id}',
      'Test Artist #{some_id}',
      'Test Album #{some_id}',
      '#{current_date}'
    );"
  end

  def stress
    start = Time.utc_now()
    cluster = MediaPlayer.Config.Database.start_link()

    # Simple stress test
    1..100_000
    |> Task.async_stream(
      fn id ->
        IO.puts("[#{id}] Adding seed")
        Xandra.Cluster.execute(cluster, generate_stress_query(id))
      end,
      max_concurrency: 500
    )
    |> Enum.to_list()

    IO.puts("Time taken: #{Time.diff(Time.utc_now(), start, :second)} seconds")
  end

Basically we have:

stress function:
- Mark the start time of the function with Time.utc_now();
- Initializes the cluster manually for better performance and handling.
- We initiate a call from 1 to 100000 that goes asynchronously:
- Define an anonymous function that receives an id;
- We print that we are adding a certain index;
- We tried to perform the query with Xandra.Cluster.execute by calling the generate_stress_query function, responsible for generating a complete query with the id provided;
- We set a max_concurrency of 500 to limit the number of asynchronous calls;
- We format it into a list;
- We print the time spent to carry out the entire test, calculating the difference between the current time and the start time in seconds;
generate_stress_query function:
- Receives an id as a parameter to generate the query;
- Sets the current date to insert;
- Returns the complete query already formatted;

Well, that way our functions for the stress test are ready! Now we must implement the command inputs that a user can enter!

Implementing user interaction

Let's modify our main module, MediaPlayer in the media_player.ex file! Well, first let's define an alias for the commands:

defmodule MediaPlayer
  alias MediaPlayer.Commands, as: Commands
end

The alias will be used to refer to the MediaPlayer.Commands module!

The first function we will implement is loop, which will be responsible for directing the commands, receiving user input and remaining in an infinite loop always waiting for input, see:

  def loop do
    IO.puts("-------------------------------------")
    IO.puts("Type any command: ")
    command = IO.gets("") |> String.trim()

    case command do
      "!add" ->
        Commands.add()
        loop()

      "!list" ->
        Commands.list()
        loop()

      "!delete" ->
        Commands.delete()
        loop()

      "!stress" ->
        Commands.stress()
        loop()

      "exit" ->
        IO.puts("Bye bye!")
        :OK

      _ ->
        IO.puts("Command not found!")
        loop()
    end
  end

Basically we wait for user input with a command and enter a case:

!add invokes the Commands.add() function;
!list invokes the Commands.list() function;
!delete invokes the Commands.delete() function;
!stress invokes the Commands.stress() function;
exit prints a goodbye message and returns :ok, defining that the function no longer enters a recursive loop, ending our application;
_ prints a command not found message and enters a recursive loop, waiting for new input;

Well, now we have our main function ready! But how are we going to execute it? Simple, let's create a start function that will be responsible for starting our application, in addition to a run function, which will be the function invoked by the initial start function, see:

  def start(_, _) do
    run()
    {:ok, self()}
  end

  def run do
    IO.puts("-------------------------------------")
    IO.puts("- ScyllaDB Cloud Elixir Media Player -")
    IO.puts("- Leave a star on the repo -")
    IO.puts("-------------------------------------")
    IO.puts("Here some possibilities")
    IO.puts(" !add - add new song")
    IO.puts(" !list - list all songs")
    IO.puts(" !delete - delete a specific song")
    IO.puts(" !stress - stress testing with mocked data")
    IO.puts("-------------------------------------")

    loop()
  end

Basically we have:

start function:
- It receives two parameters, but we will not use them, so we define them as _;
- Invokes the run function;
- Returns {:ok, self()} to define that the function was executed successfully, closing our application;
run function:
- Print a welcome message;
- Prints a message with command possibilities;
- Invokes the loop function to start the infinite loop;

This concludes our complete application! Now are we going to execute it?

Running our application

Well, now that we have our application ready, let's execute the command:

$ mix run

This way we can start interacting with the application!

See a demo of the project:

Conclusion

Thank you very much if you read this far! The purpose of this article was to demonstrate how we can use ScyllaDB with Elixir, making a simple demonstration using Xandra as responsible for the connection between the two. I highly recommend following content from ScyllaDB University for more quality educational content, as well as seeing articles about using ScyllaDB in general with DanielHe4rt and Cherry Ramatis! Both are always contributing and publishing magnificent content.

I also recommend getting to know the project Getting Started with ScyllaDB Cloud which demonstrates the use of ScyllaDB in general, but, delving a little deeper into the use of ScyllaDB's own platform for managing your Cloud clusters, cool isn't it?

In the same repository you can access the project using Elixir too, so if you want to see the complete source code, know that it is at the same link mentioned above!

I hope you enjoyed the content and I hope it clarified the use of ScyllaDB with Elixir. I also hope that you are even more interested in receiving more content like this or learning even more about Elixir. Thank you very much, and see you next time!

Open Source e Software Livre: conheça e entenda de uma vez por todas o que cada um significa

guto — Tue, 29 Aug 2023 00:31:08 +0000

Índice

Introdução
História
1. O início
2. Unix
Software Livre
Open Source
1. Incentivos
2. Valores
Definições
1. Software Proprietário
2. Software Livre X Open Source
3. Licenças
Finalização

Introdução

O intuito deste artigo é apresentar os conceitos, história e tudo que temos por trás do mundo do Software Livre e mundo de projetos de código aberto (chamados de projetos Open-Source - nome bem sugestivo).

Ao finalizar a leitura, você conseguirá entender a diferença dos dois termos e vai ainda poder se aprofundar em seus fundamentos! Não se acanhe, caso tenha alguma dúvida fique livre para perguntar! Aqui é um espaço seguro para ensino e aprendizado.

História

Em algum momento tenho certeza que você já se deparou com algum projeto de código aberto, isso mesmo, aqueles que podemos ver o código-fonte e entender todo o seu funcionamento, podendo ainda realizar modificações sobre ele de acordo com sua necessidade... Bem, esses pontos sobre poder ou não poder fazer alguma coisa vamos tratar em breve, mas, por agora entenda que é um projeto que possui o código (em alguma tecnologia específica) aberto ao público geral.

O direito de ter acesso ao código-fonte de algo vem de muito antes da computação moderna, surgindo principalmente com outros nomes e outras associações (um exemplo de forma similar seria o funcionamento de patentes), com casos datados do início do século XX, como por exemplo o caso Henry Ford de 1909, na qual houve compartilhamento de dados e informações sobre motores vazados, afinal, entramos no âmbito judicial relacionado aos direitos de uso.

No final das contas não sou do ramo de direito, sou apenas um entusiasta de projetos de código-aberto e software livre no geral, por isso, vamos passar para os tópicos que já remetem o início da computação com casos da IBM.

O início

Voltando para as décadas de 1950 e 1960 temos um mundo totalmente diferente do que vivemos hoje com relação ao uso de software. Naquela época, era comum que houvesse compartilhamento de códigos entre pessoas e empresas, incluindo a própria IBM na jogada. Sistemas operacionais e programas eram comumente distribuídos em conjunto com softwares. Um curioso fato é o nascimento do grupo de usuários SHARE que surgiu em 1955 com objetivo de facilitar o aprendizado e distribuição de software no mundo, realizando compartilhamento de tudo sobre tecnologia na época.

Em 1969 o RFC (Request for Comments e futuramente se tornando ARPANET) foi publicado, sendo o passo inicial para o que teríamos como Internet posteriormente. Ainda na mesma época temos três pessoas que foram responsáveis pelo início de um projeto que até hoje possui influência tremenda no mundo do uso de softwares no geral, estamos falando de Brian Bernighan, Ken Thompson e Dennis Ritchie, responsáveis por desenvolver uma versão modificada do MULTICS, sendo batizada como UNICS e depois Unix (já ouviu falar desse nome alguma vez?), um sistema operacional multitarefas e multiusuários.

Em 1970 a IBM (a maior vendedora e produtora de computadores de grande porte da época) que antes vendia seus softwares em conjunto com os hardwares comprados começou a vender softwares separados, trazendo o conceito do software sendo vendido simlesmente como um "produto de prateleira". Bem, o motivo para essa mudança se deu com a evolução constante de sistemas operacionais e compiladores, elevando o custo de produção para um software.

Ainda no mesmo ano a IBM realiza a compra do chamado ARPANET, iniciando um processo de monopolização na indústria de tecnologia no geral, que antes já era controlada por ela.

Unix

Anos mais tarde, em 1972, Brian Bernighan, Ken Thompson e Dennis Ritchie começaram a investir um tempo ainda maior para o desenvolvimento do Unix, com isso, algumas criações foram surgindo como por exemplo a linguagem de programação C, uma melhoria voltada para a performance da linguagem de programação B. Sim, isso mesmo que você ouviu, eles estavam tentando reescrever o Unix em B e a performance não estava das melhores, então eles pensaram "poderíamos criar uma linguagem de programação para resolver nosso problema", e então criaram. Acredito que uma grande maioria das pessoas que estejam lendo isso já tenham escrito ou visto algum código em C... Pois bem, assim foi o seu surgimento.

Em 1973 surge o chamado Unix BSD com a chegada do Unix na Universidade de Berkeley, na qual tivemos uma alavancada tremenda com o seu desenvolvimento. Com a universidade em crescimento, diversas pessoas puderam se beneficiar do compartilhamento de estudos voltados para seu desenvolvimento, resultando em um processo de comunicação incrível entre pessoas externas, alunos, professores, contribuindo para a expansão do Unix.

Em 1979 a AT&T começa a forçar licenças restritivas ao decidir que poderia lucrar com o sistema Unix, fazendo com que em 1980 surgissem os primeiros movimentos organizados em busca do que chamamos de Software Livre. Ah, apenas para finalizar este tópico, em 1981 a IBM fechou acordo com a Microsoft para fornecimento do DOS para PC, ainda desconsiderando sua evolução abriu mão dos direitos autorais do DOS, fazendo com que a Microsoft pudesse se expandir futuramente.

Software Livre

Richard Stallman publicou uma mensagem no grupo "net.unix-wizards" em 1983 com o assunto "New Unix implementation", anunciando a criação do projeto GNU (um acrônimo para "GNU's Not Unix"), declarando a necessidade da criação de um "novo Unix", mencionando a necessidade de diversas ferramentas, por isso, pedindo o apoio em contribuições. Podemos dizer que publicamente este foi a primeira declaração de Richard Stallman sobre o início de contribuições públicas para o começo do que seria um sistema operacional amplamente utilizado. As ferramentas que ele cita seriam programas para fazer com que um computador pudesse ser utilizável, incluindo tudo que você imaginar.

Bem, em 1984 Richard Stallman pediu demissão do AI Lab do MIT, se dedicando completamente ao Projeto GNU, publicando o Manifesto GNU (que cita o termo "software livre"). O primeiro software a ser publicado pelo Projeto GNU foi o chamado GNU Emacs (que também é hoje meu principal editor de código e textos no geral), escrito por Richard Stallman e Guy L. Steele.

Em 1985 o sistema de janelas X foi distribuído como software livre pleo Consórcio X (acredito que você também já deva ter ouvido falar sobre o sistema de janelas X), seguindo da fundação da Free Software Foundation e a publicação das chamadas "Quatro Liberdades de um Software Livre", sendo elas:

Liberdade 0: Liberdade de executar o programa como você desejar, para qualquer propósito;
Liberdade 1: Liberdade de estudar como o programa funciona e adaptá-lo às suas necessidades (para isso o acesso ao código-fonte é essencial);
Liberdade 2: Liberdade de redistribuir cópias de modo que você possa ajudar outros;
Liberdade 3: Liberdade de redistribuir cópias de suas versões modificadas, dando a comunidade a chance de se beneficiar de suas mudanças (acesso ao código-fonte também é essencial);

Ainda em 1985 surge o GCC (GNU Compiler Collection - tenho certeza que você também já viu esse nome em algum lugar), escrito inicialmente por Richard Stallman e Len Towe. Toda a definição oficial do que é um software livre pode ser acessada clicando aqui.

Em 1987 Andrew Tanenbaum escreveu uma versão modificada do Unix para fins didáticos, denominada MINIX (sendo posteriormente utilizada como inspiração para o nascimento do kernel Linux).

Em 1989 a Free Software Foundation criou o conceito de "copyleft" (o contrário de "copyright") e a licença GNU GPL (General Public License) que garantia as quatro liberdades de um software. Seu funcionamento se caracteriza em que eu declaro que um determinado software pertence a X, e este X não permite qualquer venda do software respeitando as quatro liberdades, amarrando o software garantindo o cumprimento das liberdades. Ainda no mesmo ano tivemos o surgimento de outros projetos Software Livre como por exemplo o PostgreSQL lançado por Michael Stonebreaker, Cygnus fundada por Michael Tiemann, David Henkel-Wallace e John Gilmore) se tornou a primeira empresa que essencialmente começou a prover serviços para software livre, entre outros.

O kernel Linux foi iniciado em 1991 por um estudante filandês da Universidade de Helsinki chamado Linus Torvalds, que anunciou o início do projeto sendo distribuído sob licença GNU GPL, fornecendo a peça final do primeiro sistema operacional completamente livre, o chamado GNU/Linux. Na época Torvalds disse que não queria dinheiro por uma série de razões, mas, que seu principal intuito era pelo sentimento de que estava "seguindo os passos de centenas de cientistas e acadêmicos", afinal, as pessoas construíram seu trabalho "apoiando-se nos ombros de gigantes".

Open Source

Bem, o termo Software Livre não remete ao software ser gratuito ou não, mas, sobre liberdade (em inglês o nome fica como Free Sofware por isso a confusão era maior), por isso, quando falamos de um software de código-fonte aberto não estamos necessariamente falando de um Software Livre. Desta forma, o termo "open source" surgiu com o intuito de separar estes dois conceitos, criado por Christine Peterson. A proposta de substituição e uso do termo surgiu partiu dela, especialmente pelo simples fato de seu trabalho estar interligado com o incentivo de práticas de sofwares open source em mercados maiores.

Incentivos

O grupo que Christine trabalhava queria mostrar ao mundo que o software ficava melhor quando era compartilhado, colaborativo, aberto e modificável, abrindo diversas possibilidades para seu uso de forma inovadora e criativa, aumentando a flexibilidade, economia, durabilidade e sem a dependência de um fornecedor (isso, você não precisa entrar em contato com um fornecedor para relatar ou sugerir algo).

Eric Raymond era um dos membros do grupo de trabalho de Christine, publicou em 1997 algumas das ideias apresentadas em seu ensaio "The Cathedral and the Bazaar", trazendo olhos para a Netscape Communications Corporation que abriu o projeto Mozilla e liberou seu código-fonte como software livre (tenho certeza que você também já ouviu falar desse nome). No formato de open source esse código se tornou posteriormente a base do Mozilla Firefox e Thunderbird.

Por conta de todo o apoio recebido ao software open source, a comunidade necessitou pensar em uma maneira de enfatizar os aspectos corporativos práticos do movimento de software livre, estabelecendo uma separação entre os termos "Open Source" e "Software Livre", na qual open source representa aspectos metodológicos, corporativos e de produção do software livre, enquanto software livre continua como representação de aspectos filosóficos sobre a liberdade de uso de software quanto ao usuário.

Em 1998 é fundada a Open Source Initiative, formalizando e estabelecendo uma definição comum em todo o setor, embora diversas empresas ainda desconfiassem do movimento open source no final dos anos 1990 e começo dos anos 2000, sendo um modelo adotado gradualmente na produção de softwares.

Valores

Os principais valores para o uso de um software open source ao invés do software proprietário pode ser definido em alguns tópicos, nos quais podemos citar de acordo com a RedHat:

Revisão por colaboradores: o código open source é sempre verificado e aprimorado por outros programadores, já que ele fica acessível a todos e a comunidade open source é muito ativa. Imagine que o código esteja sempre em transformação, em vez de ficar fechado e estagnado.
Transparência: você precisa saber exatamente que tipos de dados estão sendo transferidos e para qual lugar? Quer ver que mudanças foram feitas no código? Com o open source, é possível verificar e rastrear essas informações por conta própria, sem depender de fornecedores.
Confiabilidade: para um código proprietário receber patches e estar sempre atualizado e funcionando, ele depende do autor ou da empresa que o controlam. O código open source fica livre dos autores originais, porque é sempre atualizado por meio de comunidades ativas. Já os padrões abertos e a revisão por pares garantem que o código open source seja testado corretamente e com frequência.
Flexibilidade: como o código open source tem a modificação como foco, é possível usá-lo para solucionar problemas específicos da sua empresa ou da comunidade. Você pode usar o código da maneira que quiser, além de contar com a ajuda da comunidade e com a revisão por outros desenvolvedores quando implementar novas soluções
Custo reduzido: com o open source, o código em si é gratuito: ao trabalhar com empresas como a Red Hat, você paga apenas pelo suporte, fortalecimento da segurança e ajuda para gerenciar a interoperabilidade.
Sem dependência de fornecedor: o usuário pode utilizar o código open source em qualquer lugar, finalidade e horário.
Colaboração aberta: com as comunidades open source ativas, você encontra ajuda, recursos e perspectivas que vão além de um grupo de interesse ou empresa.

Para ver mais detalhes sobre estas definições do que chamamos de Open Source recomendo o artigo "O que é open source?" publicado pela RedHat em 2019.

Definições

Certo, agora que você já viu alguns termos e conheceu toda a história por trás de todo esse movimento, acredito que já seja hora de vermos algumas definições para que tudo possa ficar ainda mais claro.

Software Proprietário

Todo e qualquer software que não respeite as quatro liberdades de um software livre, não tenha código-fonte aberto, seja redistribuiído de maneira proprietária (pertence a algo ou alguém). São softwares que muitas das vezes precisam de alguma licença paga para utilização ou assinatura. Existem sim softwares proprietários gratuitos, por isso, a liberdade não vem do valor pago mas da etimologia empregada em um determinado software. Alguns exemplos de softwares proprietários:

Microsoft Windows
Microsoft Office
Adobe Photoshop

Software Livre e Open Source

A definição que realmente estrita os lados para que um software não seja mais considerado livre está muito mais relacionado com as decisões das organizações em si, tendo em vista que ambos os termos estão intrinsicamente ligados.

Software Livre é todo aquele em que a licença garanta as quatro liberdades de um software livre, consequentemente, ter código-fonte aberto é basicamente um pré-requisito para ser livre. Alguns exemplos de softwares livres:

Certo, mas, o que garante um software ser livre no sentido de não poderem roubar ou algo do tipo? Bem, as licenças.

Licenças

Por meio das licenças garantimos a integridade de um software, permitindo que ele possa continuar sendo um sofware livre e open source por meio de uma série de diretrizes.

Existem diversos tipos de licenças para diversas aplicações, das quais não entrarei no mérito de explicar sobre cada uma detalhadamente, mas, acredito que o diagrama abaixo pode auxiliar nesse passo.

Um software é considerado livre desde que respeite as quatro liberdades, mas, não necessariamente precise estar utilizando a licença GNU GPL.

Para ler mais sobre licenças recomendo minha publicação no GitHub que é parte de um projeto para conteúdo educacional preparatório para a certificação LPI LE-1 (da Linux Professional Institute). Para acessar o conteúdo basta clicar aqui.

Finalização

Se você chegou até aqui saiba que estou muito feliz com seu novo aprendizado. Espero que todo esse conteúdo possa ter esclarecido suas dúvidas com relação ao uso de sofwares sendo Open Source ou Software Livre.

Caso queira se aprofundar um pouco mais e conhecer melhor o mundo do software livre e mundo do Linux, saiba que existe um guia completo para preparação da certificação LPI Essentials (LPI LE-1), contendo todo o conteúdo introdutório que você precisa para começar a se aprofundar no uso de sistemas operacionais Linux! O melhor de tudo: o conteúdo é livre! Para acessar basta clicar aqui.

Agradeço as ponderações que o Aurélio A. Heckert (@aurium) fez nos comentários deste artigo, exemplificando melhor alguns casos e ainda explicando de maneira mais clara alguns detalhes sobre definições citadas anteriormente, na qual realizei uma correção.

Desde já agradeço você! Vamos crescer ainda mais o mundo de projetos Open Source e projetos de Software Livre!

Be Lazy and Increase Your Productivity: A Shell Discussion

guto — Fri, 30 Jun 2023 15:21:48 +0000

Have you ever stopped to think on how many occasions you've faced the following question: how could I improve my "productivity" as a developer? Here, the objective will be to highlight some points that you can take with you for a better lifestyle and reuse of your time, even if the word productivity is not yet a "correct" term (the term I seek to express). The title of this article may be a little curious, but I'm already advancing that it's not meant to be taken literally.

Note
This is a simple opinion article (even the first one) that I am publishing, so please know that nothing said here is something like "a definitive truth" or something like that, after all, I will only be raising points and questions for you, Dear reader. Know that any healthy discussion is more than welcome here.

Daily

Every day each person has at least one goal to accomplish, whatever it may be, which starts at the time of awakening and "should" be accomplished by nightfall. These goals are not necessarily work tasks or anything like that... They are just discreet wishes that each of us has, goals to achieve in a short period of time (or not). At the end of the day, it's these small goals that make us move every day.

The title that probably caught your eye refers to the concept of laziness.

Laziness

Noun

having or showing an unwillingness to work. "Many people start the course with a bang, but trail off after a while because of laziness, insufficient curiosity, or lack of motivation."
the fact or quality of encouraging idleness. "We relaxed in the laziness of the warm afternoon, watching as the sun began to set."

The concept of laziness is seen as a way of expressing someone who, in the inserted context, would have aversion to meeting their goals, however, the concept I want to bring is someone who would have aversion to meeting repetitive goals ( yes, generally). When we talk about someone who doesn't like to repeat the same things over and over again, doesn't like to live in the same flow of tasks or prefers not to repeat a certain action more than once, we are talking about the type of person I want to bring to the our context.

Right, but how would a person like this imply the development of productivity? Simple: people who don't like to do the same thing twice would rather "get someone to do it for them". The specific point is that this "someone" I just mentioned would be none other than our computer friends. Lazy developers prefer to automate processes instead of always repeating the same things, therefore, the energy spent is no longer to carry out the same activity every day, but to find a solution that can meet this need.

Automatic pilot

Now that you understand what kind of people this article is aimed at, I hope your doubts have been clarified (so far). Maybe it's time for you to turn on autopilot and look around at the amount of tools you can use to improve your development process.

The point in question is: with the advancement of technology and the increase in the ease of access of the population, the creation of new technologies that seek to help in people's daily lives is immense. Look around at the number of devices that make you stay connected to the Internet, whether directly or indirectly, having an impact on your life. There are many of these devices, but you as a developer may not use or even realize the powerful tools you have in your hands for consistent energy expenditure.

When I talk about tools, I'm not talking about huge platforms or highly end-user oriented tools that will make direct use of that software... I'm not even talking about other software that you should probably use to organize your schedule (they are important and necessary, but, I want to go deeper)... I'm talking about tools that for years were the beginnings of what we know as computers, which were known as the only ways to use them. Yes, I'm talking nothing less than your terminal.

Terminal

Going back to what boiled down to the main human-computer interaction interface that existed a few decades ago, we know that terminals became popular and are still used today (or at least they should be).

The image above depicts a 1981 IBM 5150 PC.

Currently, terminal emulators seek to simulate the interactions that occurred in times when a "black screen with green letters" was the only visual interface style presentable by monitors. Obviously terminal emulators are very user friendly, allowing different customizations and expanding the imagination of those who will use them (if you are interested in learning some ways to customize your terminal emulator click here and access one of my past articles).

The point I want to highlight here is: these have always been the main interfaces to be used when working with computers (in general terms). Its interface is based on an input of commands that are processed and an explicit output resulting from the processing of these commands. There is usually a bit of a misunderstanding on the part of general users to think "okay, but if technology has evolved so much, why should I continue using something like this" or "it's a waste of time to use something outdated", but I already anticipate that they are misled into thinking that way.

The main argument that favors the use of terminal emulators is simplicity. There is no middle ground, access area lock, rendering time or bad animation (whatever is a common problem of a general purpose GUI). The commands are executed, you control the computer as you wish and manage the main activities of your daily life.

There are several solutions that seek to bring real experiences similar to the use of interfaces in terminal emulators, it is not difficult to find some software that makes its appearance elegant, being able to navigate with arrows or something like that. The point at hand is: obviously the use of a graphical interface aimed at an end user is more "pleasant", after all, it was created to be used by a general user.

Okay, so does that mean that for me to increase my "productivity" I have to use a terminal emulator? No! I'm saying that exploring the use of some tools through the terminal emulator can be a new and enjoyable experience, which in the future will turn out to be of its own benefit (after all, you managed to learn something new and put the mouse aside for a bit , and could even be a benefit to your health, right?).

Scripts

Ok, the use of a terminal emulator may not be to everyone's liking, I confess, but know that mixing its use with other tools can be a powerful combination, one of which is the use of scripts! Yes, scripts in the sense of instruction orders!

Terminal emulators work on a high level of abstraction layer so that the user can execute commands to be interpreted by a shell interpreter and sent to the kernel, performing communication with the hardware. The process itself is done literally with layers of abstraction. Every command you run is checked, interpreted, and executed according to the constraints previously set in your interpreter.

The image above shows how a user's input (executed command) is made, being sent to the shell interpreter and subsequently executed.

If you use any system that is based or inspired by UNIX (such as Linux distributions, macOS, FreeBSD, OpenBSD and BSD's in general) know that you have a powerful tool to use: scripts for your shell interpreter.

The famous shell scripts that have as main interpreters (better known) GNU Bash, Zsh, Fish, TCSH among many others, have ways of executing commands (working as a programming language) directly, enabling the creation of automation routines, shortening configuration processes, among other different ways so that you can increasingly automate your development routine.

The scripts can be created in different ways, used for infinite possibilities, opening up a huge range for your learning. At this point, I will leave my mentions to the main people responsible for producing excellent quality content on the use of shell scripts and the Linux world in general:

These guys are amazing when it comes to the Linux world.

Of course, if you want to learn a little more about Linux and still prepare for a Linux Professional Institute certification, know that there is an excellent guide that will help you along the way, the famous lpi4noobs written with a lot of love and affection by the one who is writing the article you just read!

Conclusion

Learning to better utilize the tools you have around you is the best thing. Be curious, seek to learn about the use of different technologies. At the end of the day, nobody likes to perform a repetitive task on a daily basis as a developer, so maybe it's time to explore new paths and understand that this whole learning process is part of it.

I hope you enjoyed the article, I wrote it as a way to express a little more about a perspective resulting from the observation of published content related to the term "productivity", which I still consider to be a wrong term. Finally, the intention was to leave a little of the technical content itself and take a look at the environment in which we are inserted.

Be happy, thanks for reading this far.

Seja preguiçoso e aumente sua produtividade: uma discussão sobre Shell

guto — Fri, 30 Jun 2023 15:17:58 +0000

Já parou pra pensar em quantas ocasiões você se deparou com a seguinte questão: como eu poderia melhorar a minha "produtividade" como desenvolvedor? Aqui, o objetivo vai ser ressaltar alguns pontos que você pode levar consigo para um melhor estilo de vida e reaproveitamento de seu tempo, mesmo que a palavra produtividade ainda não seja um termo "correto" (o termo que busco expressar). O título deste artigo pode ser um tanto quanto curioso, mas, já adianto que não é pra levar ao pé da letra.

Nota
Este é um simples artigo (até mesmo o primeiro) de opinião que estou publicando, por isso, saiba que nada dito aqui é algo como "uma verdade definitiva" ou algo do tipo, afinal, estarei levantando apenas pontos e questionamentos para você, caro leitor. Saiba que qualquer discussão saudável é muito mais do que bem-vinda aqui.

Cotidiano

Todos os dias cada pessoa possui pelo menos uma meta para realizar, qualquer que seja, que inicia no momento do despertar e "deveria" ser cumprida até o anoitecer. Estas metas não são necessariamente tarefas do trabalho ou algo do tipo... São apenas vontades discretas que cada um de nós possui, objetivos para alcançarmos em um curto período de tempo (ou não). No final das contas, são essas pequenas metas que fazem com que a gente se movimente todos os dias.

O título que provavelmente pode ter chamado sua atenção se refere ao conceito de preguiça.

Preguiça

Substantivo feminino

aversão ao trabalho; ócio, vadiagem. "o pai não permite que os filhos vivam na p."
estado de prostração e moleza, de causa orgânica ou psíquica. "tem p. de caminhar"

O conceito de preguiça é visto como uma forma de expressar alguém que, no contexto inserido, teria aversão ao cumprimento de suas metas, porém, o conceito que estou querendo trazer é de alguém que teria aversão ao cumprimento de metas repetitivas (sim, em âmbito geral). Quando falamos de alguém que não gosta de repetir sempre as mesmas coisas, não gosta de viver sempre em um mesmo fluxo de tarefas ou então prefere por não repetir mais de uma vez determinada ação, estamos falando do tipo de pessoa que estou querendo trazer para o nosso contexto.

Certo, mas, como uma pessoa desta forma implicaria no desenvolvimento de produtividade? Simples: pessoas que não gostam de fazer a mesma coisa duas vezes preferem "dar um jeito para alguém fazer para elas". O ponto específico é que este "alguém" que eu acabei de citar, seria nada mais nada menos que nossos amigos computadores. Desenvolvedores preguiçosos preferem automatizar processos ao invés de sempre repetirem as mesmas coisas, por isso, o gasto de energia empregado não é mais para realizar a mesma atividade todos os dias, mas, para encontrar uma solução que consiga suprir esta necessidade.

Piloto automático

Agora que você já entendeu pra qual tipo de pessoas este artigo é direcionado, espero que as suas dúvidas tenham sido esclarecidas (até o momento). Talvez seja hora de você ligar o piloto automático e olhar ao seu redor vendo a quantidade de ferramentas que você pode utilizar para melhorar seu processo de desenvolvimento.

O ponto em questão é: com o avanço da tecnologia e o aumento da facilidade de acesso da população, a criação de novas tecnologias que buscam auxiliar no cotidiano das pessoas é imensa. Veja em volta o número de equipamentos que te fazem permanecer conectado na Internet, seja de forma direta ou indireta, tendo um reflexo em sua vida. Existem diversos destes equipamentos, mas, você como desenvolvedor pode não fazer uso ou nem ao menos perceber as poderosas ferramentas que tem em suas mãos para um gasto de energia coerente.

Quando eu falo de ferramentas, não estou falando de plataformas enormes ou ferramentas altamente voltadas para um usuário final que vai fazer uso direto daquele software... Não estou falando nem mesmo de outros softwares que você provavelmente deve utilizar para organizar seu cronograma (eles são importantes e necessários, mas, eu quero ir mais embaixo)... Estou falando de ferramentas que por anos eram os primórdios do que conhecemos como computadores, das quais eram conhecidas como as únicas formas de utilizarmos. Sim, estou falando nada mais nada menos do que seu terminal.

Terminal

Voltando ao que se resumia na principal interface de interação humano-computador que existia há algumas décadas, sabemos que os terminais se popularizaram e são utilizados até hoje (ou pelo menos deveriam).

A imagem acima retrata um IBM 5150 PC de 1981.

Atualmente os emuladores de terminal buscam simular as interações que ocorriam nas épocas em que uma "tela preta com letras verdes" era o único estilo de interface visual apresentável por monitores. Obviamente os emuladores de terminal são muito amigáveis, permitindo customizações diversas e expandindo a imaginação daqueles que vão utilizá-los (se você tem interesse em aprender algumas formas de customizar seu emulador de terminal clique aqui e acesse um dos meus artigos passados).

O ponto que quero destacar aqui é: estas sempre foram as principais interfaces a serem utilizadas quando trabalhávamos com computadores (no aspecto geral). Sua interface se baseia em uma entrada de comandos que são processados e uma saída explícita resultante do processamento destes comandos. Geralmente existe um tanto quanto equívoco dos usuários gerais em pensar "ok, mas, se a tecnologia evoluiu tanto por qual motivo eu deveria continuar utilizando algo deste tipo" ou então "é perca de tempo utilizar algo ultrapassado", mas, já adianto que estão enganados em pensar dessa forma.

O principal argumento que favorece o uso de emuladores de terminal é a simplicidade. Não existe meio termo, trava de área de acesso, tempo de renderização ou animação com problema (qualquer que seja um problema comum de uma interface gráfica de propósito geral). Os comandos são executados, você controla o computador como você bem quiser e consegue ainda gerenciar as principais atividades do seu cotidiano.

Existem diversas soluções que buscam trazer experiências reais similares ao uso de interfaces em emuladores de terminal, não é difícil de se encontrar algum software que faça com que sua aparência seja elegante, podendo navegar com setas ou algo do tipo. O ponto em questão é: obviamente o uso de uma interface gráfica voltada para um usuário final é mais "agradável", afinal, ela foi criada para ser utilizada por um usuário de âmbito geral.

Certo, então quer dizer que pra eu aumentar minha "produtividade" eu tenho que usar um emulador de terminal? Não! Estou dizendo que explorar o uso de algumas ferramentas pelo emulador de terminal pode ser uma experiência nova e agradável, que no futuro vai resultar em um benefício próprio (afinal, você conseguiu aprender algo novo e deixar de lado o mouse um pouco, podendo até mesmo ser um benefício para sua saúde, não é?).

Scripts

Ok, o uso de um emulador de terminal pode não ser do agrado de todos, eu confesso, mas, saiba que mesclar o uso dele com outras ferramentas pode ser uma combinação poderosa, sendo uma delas o uso de scripts! Sim, scripts no sentido de ordens de instrução mesmo!

Os emuladores de terminal trabalham em uma camada de alto nível de abstração para que o usuário possa executar comandos a serem interpretados por um interpretador de shell e enviados para o kernel, realizando a comunicação com o hardware. O processo em si é feito literalmente com camadas de abstração. Todo comando que você executa é verificado, interpretado e executado de acordo com as restrições previamente estabelecidas no seu interpretador.

A imagem acima mostra como a entrada de um usuário (comando executado) é feita, sendo enviada para o interpretador de shell e posteriormente executada.

Se você utiliza qualquer sistema que seja baseado ou inspirado no UNIX (como distribuições Linux, macOS, FreeBSD, OpenBSD e BSD's no geral) saiba que você tem consigo uma ferramenta poderosa a ser utilizada: scripts para seu interpretador de shell.

Os famosos shell scripts que possuem como interpretadores principais (mais conhecidos) GNU Bash, Zsh, Fish, TCSH entre outros diversos, possuem formas de executar comandos (funcionando como uma linguagem de programação) diretamente, possibilitando a criação de rotinas de automação, encurtamento de processos de configuração, entre outras diversas formas para que você possa cada vez mais automatizar sua rotina de desenvolvimento.

Os scripts podem ser criados de diversas maneiras, utilizados para infinitas possibilidades, abrindo um leque enorme para seu aprendizado. Neste momento vou deixar minhas menções para os principais responsáveis por produzirem conteúdos de excelentíssima qualidade sobre uso de scripts em shell e o mundo Linux de forma geral:

Blau Araujo (@blau_araujo)
Dionatan (@blogdiolinux)
Jeferson Fernando (@badtux_)
Jefferson Carneiro (@oslackjeff) > Estes caras são feras quando o assunto é mundo Linux.

Claro, se você quiser aprender um pouco mais sobre Linux e ainda se preparar para uma certificação da Linux Professional Institute, saiba que existe um guia excelente que vai te ajudar nesse caminho, o famoso lpi4noobs escrito com muito amor e carinho por este que está escrevendo o artigo que você acabou de ler!

Conclusão

Aprender a utilizar melhor as ferramentas que você tem ao seu redor é a melhor coisa. Seja curioso, busque aprender sobre o uso de tecnologias diversas. No final das contas, ninguém gosta de realizar uma tarefa repetitiva no cotidiano como desenvolvedor, por isso, talvez seja hora de explorar novos caminhos e entender que faz parte todo esse processo de aprendizado.

Espero que tenham gostado do artigo, escrevi como uma forma de expressar um pouco mais sobre uma perspectiva resultante da observação de conteúdos publicados relacionados ao termo "produtividade", que ainda assim considero como um termo errado. Por fim, o intuito foi sair um pouco do conteúdo técnico em si e dar uma olhada para o ambiente que estamos inseridos.

Sejam felizes, obrigado por lerem até aqui.

Primeiros passos com o Git

guto — Mon, 19 Jun 2023 01:40:29 +0000

O que é Git?
- De onde surgiu o Git?
Conceitos por trás do Git
- Repositório
- Commit
- Branch
- Pull Request
- Issue (bônus)
Comandos
Extra
- Git x GitHub

O que é Git?

Git é uma ferramenta/protocolo para controle de versões de um projeto (repositório). A principal finalidade do Git é controlar o fluxo de modificações que um projeto pode receber.

Além disso, o Git auxilia no decorrer do processo de desenvolvimento por conseguir facilitar o registro de modificações que um repositório pode sofrer.

De onde surgiu o Git?

Desenvolvido por nada mais nada menos que Linus Torvalds (juntamente de diversos desenvolvedores espalhados no mundo todo - poder do software livre e de código aberto neh), o Git surgiu com o principal propósito de organizar repositórios, buscando ser uma solução livre e de fácil uso.

O principal motivo que realmente fez com que o Git surgisse foi a manutenção do repositório do Kernel Linux. Depois de tentar utilizar diversas ferramentas para o versionamento, mas, nenhuma suprindo consideravelmente bem… Com isso, Linus propôs em 2004 o desenvolvimento de uma nova ferramenta, assim, surgiu-se o Git.

Conceitos por trás do Git

Repositório

Local onde temos o nosso projeto. Nele teremos todo o controle de versões e modificações realizadas. No repositório podemos navegar entre os arquivos normalmente e verificar históricos essenciais.

Um repositório pode ser nomeado com um padrão bem interessante em sistemas que utilizam o git (como GitHub e GitLab), sendo usuário/repositório.

Os repositórios podem sofrer diversas modificações, por isso, vamos entender melhor como essas modificações são realizadas.

Commit

Um commit pode ser classificado como uma publicação de modificação no repositório. Se eu altero algo de um repositório, temos o registro salvo com nome de commit, sendo apresentado quais modificações foram realizadas (desde criação de arquivos até modificações únicas de caracteres).

Com o git podemos registrar todos os commits feitos, apresentando também informações como data, mensagem, usuário que enviou o commit entre outros dados realcionados ao commit!

Branch

Podemos definir a branch como uma ramificação do nosso repositório. Nela, temos a base de outra branch (geralmente a main - antiga master) para realizar modificações.

Em projetos reais, é comum que cada modificação de projeto (algo que altere o fluxo de funcionamento) tenha uma branch específica. Cada modificação posteriormente pode resultar em uma mescla dessa branch com a principal (realizando o merge das modificações).

Pull Request

Nada mais é do que uma requisição para se realizar o merge (fundir) de uma branch em outra. Geralmente as pull requests são abertas para realizar o merge de uma branch modificada para a branch principal, resultando em um processo de aprovação.

Com a pull request aberta temos acesso às modificações que serão "mergeadas" ao se aprovar o pedido. Tome muito cuidado! As pull requests devem ser utilizadas com cautela e sempre que possível, impossibilitando modificações problemáticas.

Issue (bônus)

Geralmente sendo uma característica única de sistemas que utilizam o versionamento com git, uma issue pode ser definida como algum problema/sugestão para modificação no repositório. As issues são abertas e recebem comentários, podendo ser fechadas pelo(s) proprietário(s) do repositório.

São extremamente úteis para realizar uma verificação geral de uso, podendo ainda ser uma fonte de feedback para o repositório.

Comandos

Existem diversos comandos para se utilizar com o git, por isso, recomendo acessar a documentação de apresentação dos comandos caso queira se aprofundar melhor!

Vamos ver alguns comandos específicos do git:

git config: utilizado para configurar seu usuário
git init: inicia um repositório no diretório local
git clone: clona um repositório existente no caminho atual
git pull: sincroniza as modificações existentes que não estão atualizadas para o seu repositório
git add: adiciona arquivos para serem sincronizados e enviados
git commit: adiciona um commit com os arquivos que foram previamente modificados
git push: envia as modificações do seu repositório local para o repositório principal
git checkout: atualizar a branch que você está utilizando no momento
git merge: utilizado para fundir uma branch com outra, geralmente em paralelo com uma pull request
git log: mostra os logs de commits realizados
git revert: reverter commits realizados para uma versão anterior às modificações

Extra

Git x GitHub

Git NÃO é a mesma coisa que GitHub. Enquanto o Git é tratado como uma ferramenta, o GitHub é utilizado como um site/plataforma que realiza o uso do Git para sistema de versionamento.

O Git pode ser implementado em um servidor como desejar, independente da plataforma a ser utilizada no final. Existem diversas plataformas que utilizam o Git, entre elas o GitLab, por exemplo.

Aprenda mais sobre Git

Acesse o repositório oficial do git4noobs para aprender mais sobre Git!

Manipulating JSON files with Crystal

guto — Tue, 06 Jun 2023 01:43:34 +0000

If you ever thought about what it would be like to work with reading JSON files using Crystal, know that this is the right place! Here we will see how we can perform simple manipulations of values in JSON, working with variables, arrays, hashs, among other ways, manipulating our keys with variables!

What is JSON

The name JSON comes from "JavaScript Object Notation", being a compact open standard format for exchanging and manipulating simple data, created in the 2000s (more specifically in 2002) using a key-value format (attribute-value).
Okay, but what would a JSON file format look like?

[
    {
        "message": "talk troop"
    },
    {
        "response": "hey"
    }
]

The keys/attributes would be the fields "message" and "response", in which its value is assigned right after the colon (":"), being separated by braces ("{ }") and a comma indicating the next complete attribute.

Working with Crystal

Opening your working directory, create a new directory to work with this project, in which we will need some "dependencies" before starting:

Make sure you have Crystal installed correctly on your machine
Prepare the favorite code editor in the directory that was created
If you haven't installed Crystal yet click here to learn more! After opening your working directory, if you want to start shards to create a file to control the project, execute in your terminal:

$ shards init

Your shard.yml file should follow the following format:

name: json-reader

version: 0.1.0

authors:
    - João Lanjoni <guto@lanjoni.dev>

description: |
    JSON reader

targets:
    test:
        main: src/main.cr

license: MIT

Now create a directory called src, in it we will put all our code worked using Crystal! Also create a directory called content in the root of the project to contain all our files in JSON format!
Therefore, just add a file in JSON format with the name you want in the content directory and add a main.cr file in the src directory, so we will have our tree:

json-reader/
├── content/
│ └── index.json
├── src/
│ └── main.cr
└── shard.yml

Remembering that shard.yml only exists if you started shards inside your project!

Hands-on (on keyboard)

First, let's create our JSON file, so, following the template above, create a .json file inside the content directory! With it we will manipulate the existing values there!
Now open your src/main.cr file in your favorite code editor so we can better manipulate our project!
Opening your file first let's import the json library to work with files in this format, so add in your code:

require "json"

Every library can be added with the require command!

In order to inform which file will be read, we will perform a simple pass by argument/option when running our project! So, if you want to go a little deeper into passing arguments on the command line with Crystal, click here. In this way, let's save the content of the JSON file in a variable:

content = File.read("content/#{ARGV[0]}")

To receive the first argument/option we will use ARGV[0], after all, position 0 is the first in the array of values passed as options! The content at the beginning means that we only need to pass the file name, after all, a file with the same name will already be searched for in the specified directory!

Right, but there is still the case of the user not adding any option, right? In this case, the code should not even continue, after all, if a JSON file is not specified, then, we cannot carry out the manipulation! So, before that, we add a simple check:

if ARGV.size != 1
    puts "You must pass the filename as a parameter!"
    exit 1
end

The length being different from 1 shows that either more than one argument was passed or none at all, so in both cases we must reject the execution!

There are a few ways to parse our JSON, let's start with the simplest: JSON with unique keys! See the example JSON below:

{
    "test": "hi",
    "test2": "bye"
}

Notice that this format does not have square brackets at the beginning, indicating that it is not an array!

To perform the parse we will use a native Crystal function to read a JSON and then convert it into a Hash of Strings!

hash_content = Hash(String, String).from_json(content)

puts hash_content # {"test" => "hi", "test2" => "bye"}

In this way, we are going to assemble a variable named hash_content, having in its content a hash with a key value from String to String, bringing this data from a JSON

So our final code will look something like this:

require "json"

# Check arguments being equal to 1
if ARGV.size != 1
    puts "You must pass the filename as a parameter!"
    exit 1
end

# Loading the contents of the JSON file
content = File.read("content/#{ARGV[0]}")

# Transforming JSON file data into a String Hash => String
hash_content = Hash(String, String).from_json(content)

# Printing the contents of the variable
puts hash_content # {"test" => "hi", "test2" => "bye"}

We can run it in two ways:

Using shards:

$ shards run -- content.json
Using the crystal itself:

$ crystal run src/main.cr content.json

Okay, but what if we just wanted the test key returned?


puts hash_content["test"] # hi

Thus, we were able to manipulate our data in the JSON file, being able to bring the specific keys for each item!

JSON Arrays

Okay, but most of the JSONs we're going to find need to be "parsed" using Array formats... How can we do that? Well, there are two specific ways to accomplish this task, let's go?

First form: Hash Array

Basically let's assemble an array with its internal type being hashed! But how would that look in practice? Well, first I'll go over the JSON file we'll be working with:

[
    {
        "test": "hello"
    },
    {
        "test2": "hey"
    }
]

Let's first define that we are working with an array, but, when defining the array type, let's change it to Hash(String, String), see:

json = Array(Hash(String, String)).from_json(content)

puts json # [{"test" => "hello"}, {"test2" => "hey"}]

Notice that we've basically wrapped the previous hash format in the array, correct? So we can work with our arrays of JSONs the way we prefer! But, how could I bring only the contents of the "test" key? Simple, see two examples below:

puts json[0] # {"test" => "hello"}

puts json[0]["test"] # hello

So we can manipulate our JSON!
If the key format is not always String, we can still create an alias to manipulate the types passed by Hash or just add a pipe operator ("|") demonstrating that the type can vary, so it would be something like:

Hash(String | Float64, String | Int32)

Second way: File.open

We can also use File.open to open a file and work with its content (in which I leave the credits to cherry for being on live and leaving this very important detail), without the need to create a variable to carry out this work (as we were doing with the content variable). See an implementation below:

json = File.open("content/#{ARGV[0]}") do |file|
    JSON.parse(file)
end

puts json # [{"test" => "hello"}, {"test2" => "hey"}]

puts json[0] # {"test" => "hello"}

puts json[0]["test"] # hello

In this example we perform a simple "parse" of values and update them in the variable named json, being able to work with the values in the same format as before!

Thus, our complete project ends up in the second shape! Here's how our finished code looks:

require "json"

if ARGV.size != 1
    puts "You must pass the filename as a parameter!"
    exit 1
end

json = File.open("content/#{ARGV[0]}") do |file|
    JSON.parse(file)
end

puts json # [{"test" => "hello"}, {"test2" => "hey"}]

Finalization

With this guide and small article you learned how to manipulate JSON files and data coming from other files using Crystal, based on the key-value model that is offered, being able to create commands, specific readings, among other types of projects! To access the code developed in this article just click here!
See you next time, see you later! Crystallize your day even more! 💎 🖤

Manipulando arquivos JSON com Crystal

guto — Tue, 06 Jun 2023 00:53:38 +0000

Se você alguma vez já pensou em como seria trabalhar com a leitura de arquivos JSON utilizando Crystal, saiba que este é o lugar certo! Aqui veremos como podemos realizar manipulações simples de valores em JSON, trabalhando com variáveis, arrays, hashs, entre outras maneiras, manipulando nossas chaves com variáveis!

O que é JSON

O nome JSON vem de "JavaScript Object Notation", sendo um formato compacto de padrão aberto para troca e manipulação de dados simples, criado ainda nos anos 2000 (mais especificamente em 2002) utilizando um formato de chave-valor (atributo-valor).
Ok, mas, como seria o formato de um arquivo JSON?

[
    {
        "mensagem": "fala tropa"
    },
    {
        "resposta": "eai"
    }
]

As chaves/atributos seriam os campos "mensagem" e "resposta", na qual seu valor está atribuído logo após dos dois pontos (":"), sendo separadas por chaves ("{ }") e vírgula indicando o próximo atributo completo.

Trabalhando com Crystal

Abrindo seu diretório de trabalho, crie um novo diretório para trabalharmos com este projeto, na qual vamos precisar de algumas "dependências" antes de iniciarmos:

Tenha certeza de ter o Crystal instalado corretamente na sua máquina
Prepare o editor de código favorito no diretório que foi criado
Caso não tenha instalado o Crystal ainda clique aqui para saber mais! Após abrir seu diretório de trabalho, caso queira iniciar o shards para criação de um arquivo para controle de projeto, execute em seu terminal:

$ shards init

Seu arquivo shard.yml deverá seguir o seguinte formato:

name: json-reader

version: 0.1.0

authors:
    - João Lanjoni <guto@lanjoni.dev>

description: |
    JSON reader

targets:
    teste:
        main: src/main.cr

license: MIT

Agora crie um diretório chamado src, nele vamos colocar todo o nosso código trabalhado utilizando Crystal! Crie também um diretório chamado content na raiz do projeto para conter todos os nossos arquivos em formato JSON!
Sendo assim, basta adicionar um arquivo no formato JSON com o nome que desejar no diretório content e adicionar um arquivo main.cr no diretório src, assim, ficaremos com nossa árvore:

json-reader/ 
    ├── content/ 
    │ └── index.json 
    ├── src/ 
    │ └── main.cr 
    └── shard.yml

Lembrando que o shard.yml só existe se você iniciou o shards dentro de seu projeto!

Mãos na massa (no teclado)

Primeiramente vamos criar nosso arquivo JSON, por isso, seguindo o template passado acima crie um arquivo .json dentro do diretório content! Com ele vamos manipular os valores lá existentes!
Agora abra seu arquivo src/main.cr no seu editor de código favorito para podermos manipular melhor nosso projeto!
Abrindo seu arquivo primeiramente vamos importar a biblioteca json para trabalharmos com arquivos neste formato, assim, adicione em seu código:

require "json"

Toda biblioteca pode ser adicionada com o comando require!

Para informarmos qual será o arquivo a ser lido, vamos realizar uma simples passagem por argumento/opção ao executar nosso projeto! Assim, caso queira se aprofundar um pouco mais sobre a passagem de argumentos na linha de comando com Crystal clique aqui. Dessa forma, vamos salvar o conteúdo do arquivo JSON em uma variável:

content = File.read("content/#{ARGV[0]}")

Para recebermos o primeiro argumento/opção utilizaremos o ARGV[0], afinal, a posição 0 é a primeira no array de valores passados como opções! O content no começo significa que precisamos passar apenas o nome do arquivo, afinal, já será buscado um arquivo de mesmo nome no diretório especificado!

Certo, mas, existe ainda o caso do usuário não adicionar nenhuma opção, certo? Neste caso o código nem deve continuar, afinal, se um arquivo JSON não for especificado, logo, não podemos realizar a manipulação! Assim, antes, adicionamos uma simples verificação:

if ARGV.size != 1
    puts "É necessário passar o nome do arquivo como parâmetro!"
    exit 1
end

O tamanho sendo diferente de 1 demonstra que foram passados ou mais de um argumento ou nenhum, por isso, em ambos os casos, devemos rejeitar a execução!

Para realizar o parse de nosso JSON existem algumas formas, vamos começar com a mais simples: JSON de chaves únicas! Veja o JSON de exemplo abaixo:

{
    "teste": "oi",
    "teste2": "tchau"
}

Perceba que este formato não possui colchetes em seu início, indicando não ser um array!

Para realizar o parse vamos utilizar uma função nativa do Crystal para realizar a leitura de um JSON e depois convertê-lo em um Hash de Strings!

hash_content = Hash(String, String).from_json(content)

puts hash_content # {"teste" => "oi", "teste2" => "tchau"}

Desta forma vamos montar uma variável com nome hash_content, tendo em seu conteúdo um hash com chave valor de String para String, trazendo estes dados de um JSON

Logo, nosso código final será algo como:

require "json"

# Verificação de argumentos sendo igual a 1
if ARGV.size != 1
    puts "É necessário passar o nome do arquivo como parâmetro!"
    exit 1
end

# Carregando o conteúdo do arquivo JSON
content = File.read("content/#{ARGV[0]}")  

# Transformando os dados do arquivo JSON em um Hash de String => String
hash_content = Hash(String, String).from_json(content)

# Imprimindo o conteúdo da variável
puts hash_content # {"teste" => "oi", "teste2" => "tchau"}

Podemos executar de duas formas:

Utilizando shards:

$ shards run -- content.json
Utilizando o próprio crystal:

$ crystal run src/main.cr content.json

Certo, mas, e se quiséssemos apenas o retorno da chave teste?

puts hash_content["teste"] # oi

Assim, conseguimos manipular nossos dados no arquivo JSON, podendo trazer as chaves específicas para cada item!

Arrays de JSONs

Certo, mas, a maioria dos JSONs que vamos encontrar precisam ser "parseados" utilizando formatos de Array... Como podemos fazer isso? Bom, existem duas formas específicas para realizarmos essa tarefa, bora lá?

Primeira forma: Array de Hash

Basicamente vamos montar um array com seu tipo interno sendo hash! Mas, como isso ficaria na prática? Bom, primeiro vou repassar agora o arquivo JSON que estaremos trabalhando:

[
    {
        "teste": "fala tropa"
    },
    {
        "teste2": "eai"
    }
]

Vamos primeiramente definir que estamos trabalhando com um array, mas, no momento de definir o tipo do array vamos trocar para Hash(String, String), veja:

json = Array(Hash(String, String)).from_json(content)

puts json # [{"teste" => "fala tropa"}, {"teste2" => "eai"}]

Perceba que basicamente envolvemos o formato de hash anterior no array, correto? Assim podemos trabalhar com nossos arrays de JSONs da forma que preferirmos! Mas, como eu poderia trazer apenas o conteúdo da chave "teste"? Simples, veja dois exemplos abaixo:

puts json[0] # {"teste" => "fala tropa"}

puts json[0]["teste"] # fala tropa

Assim, conseguimos manipular nosso JSON!

Caso o formato de chave não seja sempre String, podemos ainda criar um alias para manipular os tipos passados por Hash ou então apenas adicionarmos um operador pipe ("|") demonstrando que o tipo pode variar, sendo assim seria algo como:

Hash(String | Float64, String | Int32)

Segunda forma: File.open

Podemos ainda utilizar o File.open para abrir um arquivo e trabalhar com seu conteúdo (na qual deixo os créditos para a cherry por ter passado na live e deixado esse detalhe importantíssimo), sem a necessidade da criação de uma variável para realizar esse trabalho (como estávamos fazendo com a variável content). Veja uma implementação abaixo:

json = File.open("content/#{ARGV[0]}") do |file|
    JSON.parse(file)
end

puts json # [{"teste" => "fala tropa"}, {"teste2" => "eai"}]

puts json[0] # {"teste" => "fala tropa"}

puts json[0]["teste"] # fala tropa

Neste exemplo realizamos um simples "parse" de valores e atualizamos na variável de nome json, podendo trabalhar com os valores no mesmo formato que anteriormente!

Assim, nosso projeto completo finaliza na segunda forma! Veja como ficou nosso código finalizado:

require "json"

if ARGV.size != 1
    puts "É necessário passar o nome do arquivo como parâmetro!"
    exit 1
end

json = File.open("content/#{ARGV[0]}") do |file|
    JSON.parse(file)
end

puts json # [{"teste" => "fala tropa"}, {"teste2" => "eai"}]

Finalização

Com este guia e pequeno artigo você aprendeu a como manipular arquivos JSON e dados vindo de outros arquivos utilizando Crystal, baseando-se no modelo chave-valor que é oferecido, podendo criar comandos, leituras específicas, entre outros tipos de projetos! Para acessar o código desenvolvido neste artigo basta clicar aqui!
Nos vemos na próxima, até mais! Cristalize ainda mais o seu dia! 💎 🖤

Why should you learn Crystal?

guto — Tue, 18 Apr 2023 20:21:00 +0000

Have you ever heard of this amazing language called Crystal? Okay, let's understand a little bit about everything this amazing programming language has to offer.

The purpose of this short article is to talk a little about Crystal and why you might be interested in developing using it.

What is Crystal?

Being a multi-paradigm programming language, for humans and computers, designed and developed by Ary Borenszweig, Juan Wajnerman, Brian Cardiff, in addition to more than 480 contributors to date, with syntax inspired by the Ruby language, Crystal stood out for applying concepts of concurrency and general use in a "differentiated" way, using static type checking through a global inference algorithm. Currently in active development, licensed under Apache 2.0.

History

With the first works starting in 2011 with the aim of merging the productivity and elegance of Ruby with the speed, efficiency and security of a compiled language, the so-called Joy appears, which was later renamed to Crystal.

It's first compiler was written in Ruby, but rewritten in Crystal, enabling self-hosting from November 2013, with a first version released in June 2014, in addition to joining the TIOBE index in July 2016. It's first version stable appeared in March 2021, the famous version 1.0!

Why is Crystal more efficient?

Simple, Crystal compiles native code using LLVM, excluding dynamic aspects of Ruby. It's advanced global type inference applied in the compiler, combined with union types creates a sense of a higher-level scripting language more than many other programming languages that can be compared.

In addition, Crystal has a macro system and supports method and operator overloading. It's concurrency model is inspired by sequential process communication (CSP) implementing green threads called fibers and other concepts inspired by the Go programming language. Another important point is it's automated garbage collection offering a Boehm collector.

How to install?

Installation varies for each operating system to be used! You can try installing via your default package manager by searching for the package named crystal or else follow the official installation guide!

If you are using Windows, you can either install via WSL or try the trial version of the official installer for Windows!

Shards

Shards is the name of the dependency manager in the Crystal programming language, which by default uses the shard.yml file to define project settings.

name: shards
version: 0.1.0

dependencies:
   openssl:
     github: datanoise/openssl.cr
     branch: master

development_dependencies:
   minitest:
     git: https://github.com/ysbaddaden/minitest.cr.git
     version: ~> 0.3.1

license: MIT

You can see the official repository by clicking here.

Code

Using the .cr file extension by default, let's create a practical example just showing the basis of a simple "Hello World", an HTTP server and a concurrency model!

Hello World!

p "Hello World!"
# or
puts "Hello World!"

HTTP server

require "http/server"

server = HTTP::Server.new do |context|
   context.response.content_type = "text/plain"
   context.response.print "Hello, got #{context.request.path}!"
end

puts "Listening on http://127.0.0.1:8080"
server.listen(8080)

Now just access the local page with port "8080" to test!

Concurrency Model

channel = Channel(Int32).new
total_lines = 0
files = Dir.glob("*.txt")

files.each do |f|
   spawn of
     lines = File.read_lines(f)
     channel.send lines.size
   end
end

files.size.times do
   total_lines += channel.receive
end

puts total_lines

Where can I see more about Crystal?

You can read the official documentation, follow the official language profile on GitHub and even study my own guide in Portuguese to get started with Crystal: the famous Crystal4noobs!

Por que você deveria aprender Crystal?

guto — Tue, 18 Apr 2023 20:13:17 +0000

Alguma vez você já ouviu falar dessa incrível linguagem chamada Crystal? Certo, vamos entender um pouco sobre tudo que essa incrível linguagem de programação tem para oferecer.

O objetivo deste pequeno artigo é falar um pouco sobre Crystal e por quais motivos você poderia se interessar pelo desenvolvimento utilizando-a.

O que é Crystal?

Sendo uma linguagem de programação multi-paradigma, para humanos e computadores, desenhada e desenvolvida por Ary Borenszweig, Juan Wajnerman, Brian Cardiff, além de mais de 480 colaboradores até o momento, tendo sintaxe inspirada na linguagem Ruby, Crystal se destacou por aplicar conceitos de concorrência e uso geral de uma maneira "diferenciada", utilizando verificação estática de tipos por meio de um algoritmo de inferência global. Atualmente em desenvolvimento ativo, tendo como licença a Apache 2.0.

História

Com seus primeiros trabalhos se iniciando em 2011 com o objetivo de mesclar a produtividade e elegância de Ruby com a velocidade, eficiência e segurança de uma linguagem compilada, surge a chamada Joy, que posteriormente foi renomeada para Crystal.

Seu primeiro compilador foi escrito em Ruby, mas, reescrito em Crystal, possibilitando uma auto-hospedagem a partir de novembro de 2013, tendo uma primeira versão lançada em junho de 2014, além de ingressar no índice TIOBE em julho de 2016. Sua primeira versão estável surgiu em março de 2021, a famosa versão 1.0!

Por que Crystal é mais eficiente?

Simples, Crystal compila o código nativo usando LLVM, excluindo aspectos dinâmicos do Ruby. Sua inferência de tipo global avançada aplicada no compilador, combinada com tipos de união cria uma sensação de uma linguagem de script de maior nível do que muitas outras linguagens de programação que podem ser comparadas.

Além disso, Crystal possui um sistema de macro e suporta sobrecarga de métodos e operadores. Seu modelo de concorrência é inspirado na comunicação de processos sequenciais (CSP) implementando threads verdes (tradução literal de "green threads") chamadas de fibras (tradução literal de "fibers") e outros conceitos inspirados na linguagem de programaçao Go. Outro ponto importante é sua coleta de lixo automatizada oferecendo um coletor Boehm.

Como instalar?

A instalação varia para cada sistema operacional a ser utilizado! Você pode tentar instalar pelo seu gerenciador de pacotes padrão buscando pelo pacote nomeado crystal ou então seguir o guia oficial de instalação!

Caso você esteja utilizando Windows, você pode instalar tanto pelo WSL quanto experimentar a versão de testes do instalador oficial para Windows!

Shards

Shards é o nome do gerenciador de dependências da linguagem de programação Crystal, que utiliza por padrão o arquivo shard.yml para definir configurações de projeto.

name: shards
version: 0.1.0

dependencies:
  openssl:
    github: datanoise/openssl.cr
    branch: master

development_dependencies:
  minitest:
    git: https://github.com/ysbaddaden/minitest.cr.git
    version: ~> 0.3.1

license: MIT

Você pode ver o repositório oficial clicando aqui.

Código

Utilizando por padrão a extensão de arquivos .cr vamos criar um exemplo prático apenas mostrando a base de um simples "Hello World", um servidor HTTP e um modelo de concorrência, vamos lá?

Hello World!

p "Hello World!"
# ou
puts "Hello World!"

Servidor HTTP

require "http/server"

server = HTTP::Server.new do |context|
  context.response.content_type = "text/plain"
  context.response.print "Hello, got #{context.request.path}!"
end

puts "Listening on http://127.0.0.1:8080"
server.listen(8080)

Agora basta acessar a página local com porta "8080" para testarmos!

Modelo de Concorrência

channel = Channel(Int32).new
total_lines = 0
files = Dir.glob("*.txt")

files.each do |f|
  spawn do
    lines = File.read_lines(f)
    channel.send lines.size
  end
end

files.size.times do
  total_lines += channel.receive
end

puts total_lines

Onde posso ver mais sobre Crystal?

Você pode ler a documentação oficial, seguir o perfil oficial da linguagem no GitHub e até mesmo estudar meu próprio guia em português de introdução ao Crystal: o famoso Crystal4noobs!

Taking the terminal to the next level: customizing features

guto — Fri, 06 Jan 2023 03:12:49 +0000

Presentation
Introduction
What is terminal?
Some shell types
1. Bash
2. Zsh
3. Fish
Customizations for each shell
1. Configuration files
2. Visual
  1. Bash and oh-my-bash
  2. Zsh and oh-my-zsh
  3. Fish, oh-my-fish, fisher and z
3. Nerd Fonts
Conclusion

Presentation

If you are interested in starting to use Linux in 2023, or if you already use it and want to customize and maximize your performance using the terminal, know that you are in the right place! This guide intends to show how you can use native tools from the terminal itself and customize it to make it your own, increasing your productivity and stepping out of your comfort zone!

Introduction

The terminal has been part of developers' day-to-day life for a long time, and it is possible to say that the evolution of computers to what we know today only became possible because, way back, the terminal itself was created, with that little face of "a black screen with several small letters", which, during the time when we didn't have a graphical interface, it was our means of communication with the computer.

Currently, we live in a time when technology is part of practically everyone's life, so we have become accustomed to certain interfaces and ways of solving different problems in our daily lives, resulting in an effect that makes cutting-edge technology a reality. increasingly simple to be understood by human eyes according to the levels of abstractions that are added to it.

Therefore, it is not so difficult to find someone who does not know how or does not like to use a computer via a terminal, which is characterized not as a negative phenomenon, but as a phenomenon resulting from the great reach of technology in people's lives, enabling the use of them without the need for large studies behind. Technology is in our midst and is part of our daily lives in such an intertwined way that many times we are not even able to notice it.

Punctuating this advance in technology, today, I will show you how the terminal has also evolved a lot, becoming a powerful tool, making the user who dominates the terminal and its tools become totally independent and productive during the days as a developer.

What is terminal?

Emerging at the beginning of the computing era, existing until today as an essential tool in an operating system, basically, the terminal would be nothing less than the first interface that enabled human-computer interaction, in which a sequence of commands could be sent (input), then it is processed (processing), and it returns a response (output).

The terminal "has" the appearance of a black screen even when waiting for a command entry (the word was placed in quotes because currently, not necessarily a terminal is like that, after all, it can be customized in several ways and this will be shown here later) . He is the user's contact with the "shell", and uses a command interpreter for the "shell".

Shell is nothing more than the layer that acts as an "interlocutor" between the user and the operating system kernel, being responsible for validating and sending commands to the kernel, which is responsible for managing our hardware.

Image demonstrating the process of user input and sending the instruction to the Kernel

Currently, in most Linux distributions, the terminal is found in the form of an external emulator, running as a common application in which many times some users do not even realize that we can install several other emulators that use GPU acceleration (a powerful tool for users with more "powerful" GPUs), simple visual customization, font customization, among many other possible customizations.

Using the default terminal emulator of your Linux distribution is your choice, it depends on which type of emulator you are most comfortable with, so the choice itself is up to you! I will present some customizations of Shell interpreters, moving on to a presentation of several terminal emulators that can be installed both in Linux distributions and other Unix-based operating systems, such as macOS and FreeBSD for example.

As much as it makes the text longer, the basic explanations of the operation and history of the terminal are necessary for a complete understanding, allowing you to start from that point to advance your knowledge.

Some shell types

There are several types of command interpreters, but I will mention three main ones that you can choose to use and customize, starting from its purest interface, until we reach a point where you will feel comfortable.

Bash

Used in several Linux distributions as a default command interpreter, Bash is currently maintained by the GNU project and the Free Software Foundation. Bash already has a very pleasant interface when compared to other interpreters from the GNU project itself, such as "sh" for example, which is currently found as a standard command interpreter for distributions without a native graphical interface for installation (as in some servers), or then on other Unix-based operating system projects such as FreeBSD.

Widely spread and, I believe, the most used command interpreter in Linux distributions, bash may be the perfect choice for you. Its appearance after installation can be found in different ways, but currently there are two main ones that we can highlight, which are similar to:

[guto@turing ~]$

guto@turing:~ $

Zsh

Emerging in the 1990s, zsh has caught the eye of many users over the years for being a slightly different shell than Bash. Its appearance and functionality after installation is much simpler than bash, but after a lot of customization it can become extremely powerful.

Initially being distributed with a license respecting the Berkeley standards, zsh had its skyrocket in use in macOS systems when Apple in 2020 officially switched the default shell of its operating system for bash users to zsh due to some issues involving the GNU GPL v3.0 license.

Starting zsh after installation is very simple: if you already have the zsh configuration file (it could be .zshrc for example), it will start with an appearance bringing only the machine name (very similar to sh), but, if you don't have this file yet, it will display a message alerting you that this file does not exist, in which case, pressing "0" will automatically create this empty file just to not return this message anymore. The initial appearance of zsh looks something like this:

turing%

Fish

With its initial release in 2005, fish shell has pleased many users around the world mainly due to its ease of customization, with native functions including command autocompletion with automatic suggestions, pre-configured visuals, among other diverse features.

The fish shell is also free software and includes parts of the GNU GPL v2.0 license, OpenBSD license, ISC license and NetBSD license, and can be evaluated in its repository at github. In most cases the fish shell will have to be installed externally, after all, not all distributions have it installed by default.

Its default appearance is nice and bash-like, differing by having a "fish" instead of a simple dollar sign ("$") for non-root users. Its default appearance looks like:

guto@turing ~>

The fish shell can have direct integration with your terminal emulator, allowing its customization directly from a page generated locally by executing the "fish_config" command, in which it is possible to customize the colors, functions, shortcuts, among other diverse functionalities. The generated screen looks like the image below:

Showing the fish shell configuration screen with the fish_config command

Customizations for each shell

Now, let's move on to configuring your chosen command interpreter.

Configuration files

The configuration files of each shell may vary in name, but we will address their names and how to access them, and what are the main functions that we can customize and use in our daily lives, such as creating an alias.

Bash: .bashrc or .bash_profile
Zsh: .zshrc or .zsh_profile
Fish: ~/.config/fish/config.fish

Open the file in your favorite text editor, and you may find a series of instructions that you didn't know or even had no idea what they would be for.

In this file, go to the end of it so we don't have the possibility of damaging its content or even compromising some function that you like. On the last line, we can add a series of commands that our interpreter must understand.

The first of the instructions to be created will be an example of "alias", which would be nothing more than a "nickname" for some sequence of commands that we want to execute. In this case I will create an alias to install a package with root permissions (the famous "sudo"). Our alias will look like this:

alias install="sudo apt install" # For Debian based distributions
alias install="sudo dnf install" # For Red Hat based distributions
alias install="sudo pacman -Sy" # For Arch Linux based distributions

# For macOS
alias install="brew install" # If you are using Homebrew as a package manager

Please, pay attention to which distribution you are adding the command to, after all, each one has its own package manager, right? What do you think of an article in the future talking a little about the structure of a Linux operating system?

The structure of creating an alias is very simple and respects the following structure:

alias [command]="[command to be executed when calling this alias]"

The use of aliases on a day-to-day basis is powerful and can make it much easier when it comes to productivity, which we can expand to a series of functions that we can install and customize within our configuration file, in which we are going to customize its appearance now.

Did you notice that the fish shell has a slightly different file? Well, it accepts slightly different instructions in its use, but, in order not to extend myself so much, know that you can access the official fish shell documentation.

Visual

Now you know where your command interpreter configuration file is, so you know where you can create native functions interpreted in Shell for your day-to-day! In this way, we are now going to a visual customization of each shell.

Bash and oh-my-bash

Going to the appearance, we know that bash has an appearance that may not please everyone, but that can be customized and for that there are two main ways that will be presented: using the standard command for creating appearances or through a tool that facilitates our customization, called "oh-my-bash", being maintained by an amazing community.

The line below will show how the appearance of your input line in bash can be modified by changing the PS1, responsible for leaving it with this more pleasant look:

export PS1='\u@\h:\[\e[01;32m\]\w\[\e[0m\]\$ '

Basically it leaves a "user@host:path/to/directory $" with the hostname in green! To change the foreground colors it was necessary to add the code snippet that contains some numbers inside, the color code respecting the ANSI table for bash! An important detail to remember is that according to your terminal emulator these colors may contain different shades that you can customize yourself!

Table of colors and ANSI codes displayed by the terminal

Support for the so-called "true color", which would be the 256 RGB colors varies according to the terminal emulator you are using.

Right, but what if I want to perform a simpler customization without the need to change color codes or already use some existing customization, can I do it? The answer is yes, you can, and the oh-my-bash project came about for just that purpose!

Accessing the official website you can browse the documentation, contribute and view the themes already published, and their installation can be done using curl or wget. If you haven't installed any of the two packages yet, just use the following commands:

wget

sudo apt install wget # For Debian based distributions
sudo dnf install wget # For Red Hat based distributions
sudo pacman -Sy wget # For Arch Linux based distributions

# For macOS
brew install wget # If you are using Homebrew as a package manager

curl

sudo apt install curl # For Debian based distributions
sudo dnf install curl # For Red Hat based distributions
sudo pacman -Sy curl # For Arch Linux based distributions

# Para macOS
brew install curl # If you are using Homebrew as a package manager

After installing, just open a new tab of your terminal emulator to update and you will be able to see that the default theme has been changed! To browse between the oh-my-bash themes, just click on the themes tab and access the repository which presents all the themes and choose one of your interest.

Once you choose, just open the bash configuration file (.bashrc or .bash_profile) and right at the beginning of the file you will see something like:

OSH_THEME="font"

Just change the name "font" to the name of the theme you want to put (without removing the quotes), and that's it! Now just restart your terminal emulator or open a new tab and you'll be in your new look! Did you like it?

Zsh and oh-my-zsh

The configuration of the look of zsh shell starts from the same principle as bash with the creation of a variable "PS1" that can be accessed in the tab above.

oh-my-zsh is a project maintained by a community just like the oh-my-bash project, however, it has some differences that make this community huge, ranging from complete documentation to even a store of products from the which we can purchase t-shirts, stickers, among others.

Accessing the official website project we can view a simple installation guide using curl or wget, in which it was previously shown how we can install both tools.

After installation, we can easily browse the oh-my-zsh themes tab (which is also available on the website) and choose a theme from our preference that, when opening our configuration file (.zshrc or .zsh_profile for example) we will come across something similar at the beginning of our configuration file:

ZSH_THEME="robbyrussell"

To change the theme and choose the theme of your personal taste, just change the name that is between quotes to the name of the theme you want to install and then open a new tab of your terminal emulator to boot with the new theme working normally!

Fish, oh-my-fish, fisher and z

The fish shell, as mentioned earlier, has some additional settings that can be used to customize our shell and in this case, we can handle and manipulate plugins within it.

The fish configuration file is found in the path "~/.config/fish/config.fish" and we can customize the entry using "PS1", just like in bash and zsh. If you want a slightly nicer interface to customize its operation, just use the "fish_config" command, which will open a mini local server so that your changes take effect in real time.

Like oh-my-bash and oh-my-zsh, oh-my-fish came up with the possibility for users to use pre-defined themes published and maintained by the community as a way to provide a better use of the fish shell. Oh-my-fish does not have an official page, but its repository is published on GitHub and can be installed in several ways, but with the simple installation script we will use the command:

curl https://raw.githubusercontent.com/oh-my-fish/oh-my-fish/master/bin/install | fish

If you have any problems with the installation, just access the official GitHub page of oh-my-fish and install by directly cloning the official repository, as shown in the README of the project.

The themes can be accessed and chosen according to your taste and their installation can be done with the command:

omf install URL # To enter the theme URL
omf install user/repo # To enter the theme repository
omf install name # To enter the theme name from the list of pre-installed themes

Now, starting with the usability customization of the fish shell we can mention fisher, which is a plugin manager for the fish shell, being used to install several repositories with functionalities incredible things that fish shell can offer.

To install fisher just run the following command:

curl -sL https://git.io/fisher | source && fisher install jorgebucaran/fisher

After installed you can check a list of plugins that shows several that are used by the community.

The big icing on the cake comes now, with the plugins being able to be customized and their appearance being unique: z. That's right, this name, the "z" has the function of working to record the directories you visit and create shortcuts that facilitate your navigation within your operating system. To install z with fisher just run the following command:

fisher install jethrokuan/z

After that, you can start using your terminal emulator normally, until it manages to register repetitive entries in a directory to create several shortcuts. If in doubt, z's manual can still be accessed on GitHub.

If you want more extensive configurations involving the fish shell, I recommend watching Takuya Matsuyama's channel called "devaslife" and a specific video in which he shows how to configure the fish shell in your daily life.

Nerd Fonts

In our daily lives, many times we will find several special characters or symbols formed that, when we type, do not form exactly what we would like. A practical example would be when we're writing our code and the "!=" doesn't look like it does in math, or the "->" doesn't look that much like an arrow.

It was from this need that "Nerd Fonts" emerged, with the aim of supplying and making our code editor look cooler, working in our terminal and making special symbols understood and presented in the expected way.

The homepage has a link to the offiical repository of the project, showing its releases and updates with new fonts. To install the fonts is very simple: you can install by downloading the zipped files and installing the fonts, or, install by your package manager.

The number of symbols that these fonts can reach is enormous, allowing for several customizations.

Comparison of "Nerd Fonts" with various icons and symbols and their compatibility

Conclusion

The use of the terminal in the day-to-day of the developer can be useful in infinite ways. Knowing how to be independent and being able to use the terminal is a job that requires dedication, but which is certainly worth every second of learning.

The terminal is a powerful tool and may be the only one a developer can use in their daily lives as long as they know how to use it correctly.

Customizing the terminal is not a waste of time, it's a learning process to make your work environment more comfortable and accessible to your personal tastes, making you feel satisfied.

Regardless of the shell you choose, how you customize it and which terminal emulator you like, I hope this guide has helped you and added something new to your learning experience.

DEV Community: guto

Meet Datomic: the immutable and functional database.

Table of Contents

What is Datomic?

Concept

Architecture

How can I store data?

Peers

Transactor

Storage Services

Data structure

Datoms

Entities

Schemas

How a transaction works?

Conclusion

Conhecendo o ecossistema Crystal: ferramentas e projetos

Índice

O que é Crystal?

Ruby e Crystal

Integração nativa com LibC

Ferramentas

Language Server Protocol (LSP)

Read-Eval-Print Loop (REPL)

Code style linter

Debugger

Gerenciador de dependências

Livro

Documentação

Patterns

Frameworks

Kemal

Amber

Lucky

Marten

Projetos com Crystal

Finalização

How to write a CRUD CLI using Elixir and ScyllaDB

Table of Contents

Starting the project

Installing Elixir

Installing ScyllaDB

Starting our project

Configuring the project

Defining dependencies

Configuring .env

Defining our connection module

Implementing actions with the database

Commands

Add

List

Delete

Stress

Implementing user interaction

Running our application

Conclusion

Open Source e Software Livre: conheça e entenda de uma vez por todas o que cada um significa

Índice

Introdução

História

O início

Unix

Software Livre

Open Source

Incentivos

Valores

Definições

Software Proprietário

Software Livre e Open Source

Licenças

Finalização

Be Lazy and Increase Your Productivity: A Shell Discussion

Daily

Laziness

Automatic pilot

Terminal

Scripts

Conclusion

Seja preguiçoso e aumente sua produtividade: uma discussão sobre Shell

Cotidiano

Using the `crystal` itself:

Utilizando `shards`:

Utilizando o próprio `crystal`: