Esse artigo é um resumo feito no intuito de servir como fixação dos conteúdos da matéria de Banco de Dados, no curso de Gestão da T.I - FAPAM 2º Período.

Aulas ministradas pelo professor Gabriel Ribeiro Diniz.

Os comandos SQL serão em sua grande maioria voltados ao SGBD PostgreSQL, já que é o SGBD estudado no curso.

Visão (VIEW)

A "Visão" é uma tabela virtual, na qual os dados não estão fisicamente armazenados. É uma forma de visualizar os dados de uma ou mais tabelas, sem a necessidade de armazenar esses dados em uma tabela física, ela usa dados de tabelas físicas para criar uma tabela virtual, como se fosse um "atalho" para uma consulta complexa nas tabelas físicas.

TABELAS BASE X TABELAS VIRTUAL

• Tabela Base: Tuplas (linhas) estão fisicamente armazenadas no banco de dados.
• Tabela Virtual: Somente a estrutura (esquema) da tabela é armazenada no banco de dados, e não as tuplas.

Para que usar visão?

Deve-se usar visões quando for frequente consultas com junção de várias relações (tabelas), bastando definir estas junções como uma visão e posteriormente consulta-la, na claáusula FROM.

Desse modo, o objetivo principal de uma visão é simplificar as consultas frequentes de dados, ocultando a complexidade dessas consultas SQL.

Criando uma visão

Podemos usar o comando CREATE VIEW{:sql} antes de uma consulta convenvional no banco.

CREATE VIEW nome_da_visao AS <consulta>;

Exemplo:

CREATE VIEW vw_contato_cliente AS SELECT id, nome, email, telefone FROM Cliente;

Fisicamente, os dados em vw_contato_cliente são os mesmos que em Cliente, mas a visão vw_contato_cliente é uma forma mais simples de acessar esses dados.

Após ser criada, uma visão pode ser consultada normalmente, com a cláusula FROM, como se fosse uma tabela base.

SELECT nome, email FROM vw_contato_cliente;

Sendo assim, se você atualizar os dados da tabela Cliente, a visão vw_contato_cliente também será atualizada, pois ela é uma "referência" para a tabela Cliente.

Outras visões podem ser criadas a partir de visões existentes, e assim por diante (visões sobre visões).

Podemos criar também visões apartir do resultado de múltiplas tabelas. Considere as seguintes tabelas:

CIA_AEREA

VOO

Exemplo 1 - Recuperar o nome da companhia aérea, e os voos que cada um oferece.

SELECT CA.NOME, V.NUM_VOO FROM VOO V INNER JOIN CIA_AEREA CA
ON V.CODIGO_CIA = CA.CODIGO_CIA;

Isso vai nos dar o seguinte retorno:

resultado da consulta

Podemos facilitar essa consulta criando uma "tabela virtual" apartir desse retorno, ou seja, uma visão!

CREATE VIEW vw_voos_por_cia AS
SELECT CA.NOME, V.NUM_VOO FROM VOO V INNER JOIN CIA_AEREA CA
ON V.CODIGO_CIA = CA.CODIGO_CIA;

Agora é só consultar a visão vw_voos_por_cia que vamos obter o mesmo resultado da nossa primeira consulta:

SELECT * FROM vw_voos_por_cia;

vw_voos_por_cia

Podemos também criar visões renomeandos as colunas da tabela base na view, por exemplo:

Sintaxe

CREATE VIEW nome_da_visao (coluna1, coluna2, coluna3, ...) AS <consulta>

Exemplo - Recuperar o nome da companhia aérea e o número de voos que cada uma oferece. Seguindo o exemplo dos voos, considere as seguintes tabelas:

CREATE VIEW total_voos (cia_aerea, numero_voos) AS
SELECT nome, COUNT(num_voo)
  FROM VOO V INNER JOIN CIA_AEREA CA
  ON V.CODIGO_CIA = CA.CODIGO_CIA
GROUP BY nome;

SELECT * FROM total_voos;

SELECT * FROM total_voos WHERE numero_voos >= 2;

Vantagens

As views sãi uma simplificação das consultas que são frequente na aplicaçao, e auxilia no processo de autorização/segurança.

Assim, o acesso não será mais à tabela base VOO e sim, à visão criada a partir da tabela VOO.

Atualização de uma VIEW

O SGBD não garante que uma visão sempre atualizará. Uma view com uma única tabela de definição é atualizável.

UPDATE <nome da visão> SET <valores> WHERE <condição>;

As views definidas sobre múltiplas tabelas usando junções, geralemnte não são atualizáveis.

As views definidas com funções de agrupamente (GROUP BY{:sql}) e agregação (SUM{:sql}, AVG{:sql}, COUNT{:sql}, MAX{:sql}, MIN{:sql}) não são atualizáveis.

Considerações:

A visão não é montada no instante de sua definição, mas sim no momento em que alguma consulta for realizada sobre ela (pois é uma tarefa custosa, em termos de desempenho, manter todas as tuplas se elas não estão sendo usadas em nenhuma consulta).

Em outras palavras, apenas o esquema da visão é armazenado no banco de dados. Todas as vezes que a visão é consultada, o SGBD calcula quais tuplas seriam retornadas por aquela consulta e exibe na tela.

Exemplo - Considerando a seguinte visão:

CREATE VIEW vw_voos_sem_tarifa AS
SELECT NUM_VOO, PARTIDA, DESTINO FROM VOO;

Se tentarmos atualizar essa view diretamente, a tabela base VOO será atualizada, porém o campo Tarifa da tabela VOO terá o valor NULL pois ela não esta sendo referenciada na view.

Exclusão de uma VIEW

Podemos usar o comando DROP VIEW{:sql} para excluir uma visão.

DROP VIEW <nome_da_visao>;

Ela ficará disponível até que seja executado o comando para deletá-la. É possível excluir visões quando elas não forem mais necessárias, desta forma elas não farão parte do SGBD.

Exemplo

DROP VIEW vw_voos_por_cia;
DROP VIEW vw_voos_sem_tarifa

Alterar o nome da VIEW

Comando para renomear uma visão:

ALTER VIEW <nome_da_visao> RENAME TO <novo_nome_da_visao>;

Exemplo

ALTER VIEW vw_voos_por_cia RENAME TO vw_voos_por_companhia;

Mudar o código (consulta) da VIEW

Comando para alterar o código de uma visão:

CREATE OR REPLACE VIEW <nome_da_visao> AS <nova_consulta>;

Exemplo

CREATE OR REPLACE VIEW vw_teste AS
SELECT * FROM VOO
WHERE tarifa >= 500.00;

Procedimentos (PROCEDURES)

As Stored Procedures são rotinas definidas no banco de dados, indentificadas pelo por um nome pelo qual podem ser invocadas. Um procedimento pode executar uma série de de instruções e receber parâmetros.

Para que usar stored procedures?

Muitas vezes é requerido várias consultas e atualizações no DB, o que acarreta um maior consumo de recursos pela aplicação (desempenho, memória, etc.). No caso de aplicações web, isso se torna mais visível, devido a maior quantidade de informações que precisam trafegar pela rede e de requisições ao servidor.

Uma boa forma de contornar e atenuar esses consumo de recurso diretamente pela aplicação, é transferir parte do processamento para o DB. Assim, considerando que as máquinas servidoras geralmente têm configurações de hardware mais robustas (e nada se pode garantir com relação às máquinas clientes), essa pode ser uma "saída" a se considerar.

Usar ou não usar procedures?

Como exemplo para o funcionamento dos Stored Procedures, iremos comparar a execução de uma rotina utilizando e outra não utilizando essa técnica.

Considere o seguinte contexto de uma aplicação comercial:

• O cliente fez um pedido no qual são inseridos itens
• O pedido (bem como os itens) permanecem com status "PENDENTE" até ser confirmado.
• O operador confirma o pedido e faz o registro no livro caixa.

Até o pedido ser confirmado, nenhum lançamento é feito no livro caixa, então é preciso ter uma rotina de confirmação de pedido, que deve executar as seguintes ações:

1. UPDATE{:sql} Atualizar o status do pedido (fechado, pendente)
2. UPDATE{:sql} Atualizar o status dos itens do pedido (vendido, pendente)
3. INSERT{:sql} Lançar o valor do pedido no caixa (preço)

Temos então pelo menos 3 instruções de atualiação e/ou inserção. Poderíamos representar essa sitação graficamente pela figura:

Por outro lado, poderíamos agrupar essas três instrulções no corpo de um procedimento e chamá-lo a partir da aplicação uma única vez.

As ações de UPDATE{:sql}/INSERT{:sql}/DELETE{:sql}, apartir daí, ficariam por conta do servidor. A representação gráfica desse modelo é mostrada a seguir (Através do procedimento chamado "CONFIRMAR PEDIDO"):

Criando uma PROCEDURE

Sintaxe

CREATE PROCEDURE nome_da_procedure(parametro1 tipo, parametro2 tipo, ...)
LANGUAGE SQL AS
$$
  <corpo da procedure>
$$;

Onde, parametro1, parametro2, ... são os parâmetros que a procedure pode receber (opcionais, caso não ouver, deve se passar parênteses vazios nome_da_procedure()), LANGUAGE SQL indica que a procedure será escrita em SQL, $$ é um delimitador de bloco de código e <corpo da procedure> é o código SQL que será executado.

Exemplo

CREATE PROCEDURE insert_cliente(nome VARCHAR(39), cpf VARCHAR(11), celular VARCHAR(11))
LANGUAGE SQL AS
$$
  INSERT INTO CLIENTE (nome, cpf, celular)
  VALUES ((SELECT MAX(codigo_cliente) + 1 FROM cliente), nome, cpf, celular);
$$;

Tendo criado a procedure, chamá-lo é bastante simples. Para fazer isso fazemos o uso da palavra reservada CALL, como mostra o código a seguir:

CALL <nome procedimento>(<parâmetros>);

Exemplo

CALL insert_cliente('Mateus Felipe', '00000000000', '37999999999');

Atualizando PROCEDURES

Para atualiza o código de uma procedure, basta usar o comando CREATE OR REPLACE PROCEDURE{:sql}.

CREATE OR REPLACE PROCEDURE update_preco(novo_preco NUMERIC, codigo_produto INTEGER)
LANGUAGE SQL AS
$$
  UPDATE PRODUTO SET preco = novo_preco WHERE codigo_produto = codigo_produto;
$$;

Excluindo PROCEDURES

Assim como outras estruturas no banco de dados, para exclusão de procedures basta fazer:

Sintaxe

DROP PROCEDURE nome_da_procedure;

Exemplo

DROP PROCEDURE insert_cliente;
DROP PROCEDURE update_preco;

Funções (FUNCTIONS)

Funções (Function) são rotinas definidas no banco de dados, identificadas por um nome, pelo qual podem ser invocadas, parecidos com uma procedure, recebendo parâmetros, executando instruções, mas com o diferencial de que uma função sempre retorna um valor.

Outro diferencial das funções em relação aos procedimentos, é que ela não precisa da palavra resrvada CALL para ser invocada, basta chamar a função no meio de uma consulta SQL.

Sintaxe

CREATE FUNCTION nome_da_funcao(parametro1 tipo, parametro2 tipo, ...)
RETURNS tipo_retorno
LANGUAGE plpgsql AS
$$
  DECLARE
    -- declaração de variáveis
  BEGIN
    -- lógica
  END;
$$;

Exemplo

CREATE FUNCTION getNumeroFilmes(dataInicial DATE, dataFinal DATE)
RETURNS INTEGER
LANGUAGE plpgsql AS
$$
  DECLARE
    contadorFilmes INTEGER;
  BEGIN
    SELECT COUNT(*) INTO contadorFilmes FROM FILME
    WHERE data_lancamento BETWEEN dataInicial AND dataFinal;

    RETURN contadorFilmes;
  END;
$$;

Observações

A declaração de novas variáveis pode ser necessária no corpo da função!

Tendo criado a funcion, como executa-la? Como na maioria das vezes haverá um tipo de retorno, a chamada da mesma poderá ser feita após o SELECT{:sql}, ou após a cláusula WHERE{:sql}, sendo, para este último caso, o valor retornado deve ser comparado a alguma condição.

Exemplo

SELECT contar_filmes('AÇÃO') FROM Filmes;

SELECT * FROM Filmes
WHERE tipo = pegar_tipo_com_mais_filmes();

Atualizando FUNÇÕES

Para atualizar o código de uma função, basta usar o comando CREATE OR REPLACE FUNCTION{:sql}.

CREATE OR REPLACE FUNCTION getNumeroFilmes(dataInicial DATE, dataFinal DATE)
RETURNS INTEGER
LANGUAGE plpgsql AS...

Excluindo FUNÇÕES

Para exclusão de funções, basta fazer:

Sintaxe

DROP FUNCTION nome_da_funcao;

Exemplo

DROP FUNCTION getNumeroFilmes;

Gatilhos (TRIGGER)

Triggers são objetos do banco de dados que, relacionados a certa tabela, permitem a realização de processamentos em consequência de uma dererminada ação sobre a tabela.

As triggers são uma forma de automatizar certas ações com base em eventos ocorridos. Podem ser executadas antes BEFORE{:sql} ou depois AFTER{:sql} de uma operação de inserção INSERT{:sql}, atualização UPDATE{:sql} ou exclusão DELETE{:sql} de registros.

Em aplicações que utilizam banco de dados, que ações sejam disparadas em resposta como consequência de outras, realizando operações de cálculo, validação e, em geral, surtindo alterações na base de dados automaticamente.

VANTAGENS:

• Parte do processo que seria executado pela aplicação (sistema/software) passa para o banco de dados, poupando recursos da máquina cliente.
• Facilita a manutenção, sem que seja necessário alterar o código da aplicação.

SINTAXE:

CREATE TRIGGER <Nome do gatilho>
<Momento> <Evento> ON nome_da_tabela
FOR EACH ROW EXECUTE FUNCTION <Funcao>;

Momento aqui se refere a quando a trigger será executada, podendo ser BEFORE{:sql} (antes) ou AFTER{:sql} (depois) de um evento. O evento é a operação que dispara a trigger, podendo ser INSERT{:sql} (inserção), UPDATE{:sql} (atualização) ou DELETE{:sql} (deleção).

Mas antes de criarmos a trigger de fato, precisamos criar a função que será executada pela trigger. Aqui, reaproveitaremos o conteúdo passado no tópico anterior sobre Funções, introduzindo alguns conceitos novos.

Primeiro vamos pegar uma função a ser executada pela trigger em um UPDATE{:sql}, e explicar os elementos que a compõem.

Exemplo de uma function que possui os elementos OLD e NEW:

CREATE OR REPLACE FUNCTION atualizar_preco()
RETURNS TRIGGER
LANGUAGE plpgsql AS
$$
BEGIN
  IF NEW.preco <> OLD.preco THEN
    INSERT INTO HISTORICO_PRECO (codigo_produto, preco_antigo, preco_novo)
    VALUES (NEW.codigo_produto, OLD.preco, NEW.preco);
  END IF;
  RETURN NEW;
END;
$$;

CREATE TRIGGER trigger_atualizar_preco
BEFORE UPDATE ON PRODUTO
FOR EACH ROW EXECUTE FUNCTION atualizar_preco();

Essa é uma função que será executada antes de uma atualização na tabela PRODUTO. O que ela faz é verificar se o preço novo é diferente do preço antigo, e se for, insere um registro no histórico de preços.

Elementos:

• OLD: refere-se ao valor antigo da linha que está sendo atualizada.
• NEW: refere-se ao valor novo da linha que está sendo atualizada.
• RETURN NEW: é necessário para que a atualização seja efetivada.
• IF NEW.preco <> OLD.preco THEN: é uma condição que verifica se o preço novo é diferente do preço antigo. Se for, é feito um registro no histórico de preços.
• INSERT INTO HISTORICO_PRECO: é a instrução que insere o registro no histórico de preços.

Excluindo TRIGGERS

Para exclusão de triggers, basta fazer:

DROP TRIGGER nome_da_trigger;

Fontes

• Slides das aulas do professor Gabriel Ribeiro Diniz.
• Trigger.md por Guilherme Guimarães Oliveira

Docker Compose é uma ferramenta popular para definir regras e rodar múltiplos containers Docker de ume vez. Um arquivo Docker Compose é escrito em YAML, um padrão de serialização de dados legível para humanos. Um dos recursos menos conhecidos do YAML — e por tabela do Docker Compose — é a habilidade de usar âncoras e alias para reusar partes de um documento YAML. Esse post vai se aprofundar na compreesão desses conceitos.

O básico: Âncoras & e Alias * no YAML

O YAML permite um truque bacana chamado “anchoring” que, em essência, permite que você crie uma referência ou “âncora” para qualquer valor ou sequência. Uma vez ancorado, esse valor pode ser referenciado em outro lugar no documento YAML usando o que é chamado de “alias”.

Ancoragem (&): Este é o ato de marcar uma chave, valor ou sequência com um identificador, efetivamente criando uma “referência nomeada”.

Aliasing (*): Depois de criar uma âncora, você pode se referir a ela usando um alias.

defaults: &default_config
  timeout: 10
  retries: 3

connection1:
  <<: *default_config
  url: http://example.com

connection2:
  <<: *default_config
  url: http://another.example.com

No YAML acima, connection1 e connection2 usam as configurações definidas na chave defaults.

Aplicando âncoras e aliases no Docker Compose

O poder real desse recurso YAML se torna evidente quando o aplicamos aos arquivos do Docker Compose, onde frequentemente encontramos blocos repetidos de configuração.

Suponha que temos dois serviços que compartilham algumas configurações comuns, mas têm mapeamentos de porta exclusivos:

x-shared-configuration: &shared-config
  image: my-app-image
  environment:
    - MY_ENV=VALUE

services:
  service1:
    <<: *shared-config
    ports:
      - "8080:8080"
  
  service2:
    <<: *shared-config
    ports:
      - "8081:8081"

Ao usar a chave merge <<, dizemos ao YAML para pegar todos os pares de chave-valor do nosso mapeamento ancorado e adicioná-los ao mapeamento atual. Isso pode reduzir significativamente a redundância em nossos arquivos Docker Compose, tornando-os mais concisos e legíveis.

Quando usar âncoras e aliases

Aqui estão alguns casos ao considerar esse recurso no Docker Compose:

Configuração compartilhada: conforme demonstrado, quando vários serviços compartilham configurações comuns, a ancoragem ajuda a evitar repetições.

Serviços de modelo: se você tem uma configuração de serviço base e deseja criar variações desse serviço com pequenas diferenças.

Legibilidade: em arquivos maiores do Docker Compose, blocos repetidos de configurações podem tornar o arquivo mais difícil de navegar. As âncoras podem ajudar a simplificar a estrutura.

Conclusão

As âncoras e aliases do YAML oferecem uma maneira eficiente de reutilizar partes de um documento, tornando os arquivos do Docker Compose mais fáceis de manter e legíveis. Esse recurso, embora às vezes esquecido, pode mudar o jogo para aqueles que buscam otimizar seus fluxos de trabalho do Docker. Boa conteinerização!

Esse artigo é um resumo feito no intuito de servir como fixação dos conteúdos da matéria de Banco de Dados, no curso de Gestão da T.I - FAPAM 1º Período.

Aulas ministradas pelo professor Gabriel Ribeiro Diniz.

Os comandos SQL serão em sua grande maioria voltados ao SGBD PostgreSQL, já que é o SGBD estudado no curso.

Linguagem SQL

SQL (Structured Query Language) é uma linguagem de consulta estruturada, que é usada para manipular e recuperar dados de um banco de dados relacional. SQL é uma linguagem padrão para acessar e manipular bancos de dados.

Tem como base a álgebra relacional e o cálculo relacional.

O SQL é dividido em três partes principais:

DDL (Data Definition Language) - Linguagem de Definição de Dados
Define esquemas e tabelas, chaves primárias, chaves estrangeiras, exclusão de esquemas, tabelas e colunas, alteração de tabelas.
Diz respeito à estrutura das tabelas e esquemas no DB.

DML (Data Manipulation Language) - Linguagem de Manipulação de Dados
Consulta, inserção de dados no DB, exclusão de dados, alteração de dados. Diz respeito aos dados das tabelas do BD - CRUD ¹

DCL (Data Control Language) - Linguagem de Controle de Dados
Define permissões.

Principais comandos

DDL - Definição de dados: CREATE{:sql}, DROP{:sql}, ALTER{:sql}.
DML - Manipulação de dados: SELECT{:sql}, INSERT{:sql}, UPDATE{:sql}, DELETE{:sql}.
DCL - Controle de dados: GRANT{:sql}, REVOKE{:sql}.

Conceitos

DDL - Data Definition Language

DDL - Data Definition Language (Linguagem de Definição de Dados) é usada para definir a estrutura que armazenará os dados. Define a estrutura das tabelas, índices, chaves primárias, chaves estrangeiras, etc.

Propriedades

A DDL permite não só a especificação de um conjunto de relações (tabelas), como também informações acerca de cada uma das relações, incluindo:

• O esquema de cada relação (estrutura)
• O domínio dos valores associados a cada atributo (int, float, varchar, etc)
• As regras de integridade de cada uma das relações
  • O conjunto de índice para manutenção de cada uma das relações
  • Informações sobre segurança e autoridade sobre cada relação
  • A estrutura de armazenamento físico de cada relação no disco.

Criar banco de dados/esquema

Antes de qualquer tabela, é necessário criar um database (banco de dados) ou um schema (esquema). Em SQL uma base de dados (ou esquema) é identificada atravez de um nome. Os elementos do esquema incluem tabelas, restrições, etc.

Sintaxe:

CREATE DATABASE nome_do_banco;

ou

CREATE SCHEMA nome_do_esquema;

Exemplos:

CREATE SCHEMA Empresa;
CREATE SCHEMA Universidade;
CREATE DATABASE Hospital;

Tipos de domínios

Numéricos

INTEGER{:sql}: É um inteiro, originado da palavra integer (em inglês).

NUMERIC(p,d){:sql}: É um número de ponto fixo cuja precisão é definida pelo usuário. O número consiste de $p$ dígitos (mais o sinal), sendo que $d$ dos $p$ dígitos estão à direita do ponto decimal.
Ex. NUMERIC(4,2){:sql}: 42,00

SERIAL{:sql}: Números inteiros auto incrementados.

Caracteres (Strings)

CHAR(n){:sql}: É uma cadeia de caracteres de tamanho fixo, com o tamanho $n$ definido pelo DBA². Abreviação de character (em inglês).
Ex. CHAR(12){:sql}: Jack Sparrow

VARCHAR(n){:sql}: É uma cadeia de caracteres de tamanho variável, com o tamanho $n$ definido pelo DBA. Abreviação de character varying (em inglês).

Booleano

BOOLEAN{:sql}: É um tipo de dado que pode ter um dos dois valores possíveis: TRUE ou FALSE (verdadeiro ou falso).

Data/Tempo

DATE{:sql}: É um tipo de dado que contém um ano (com 4 dígitos) mês e dia do mês sendo o formato "aaaa/mm/dd" o padrão do MySQL Workbench.

• ano (date) - retorna o ano de uma data
• Month (date) - retorna o mês de uma data
• Day (date) - retorna o dia de uma data

TIME{:sql}: Representa um horário, com o formato "hh:mm:ss" (00:00:00).

Observações

• Uma chave estrangeira deve possuir o mesmo típo de domínio da chave primária correspondente.
• O valor nulo NULL{:sql} é um membro de todos os tipos de domínio, isto é, qualquer atributo pode receber o valor NULL{:sql} exceto aqueles que são chaves primárias (restrição de integridade de entidade).
• O SQL permite que a declaração de domínio de qualquer atributo inclua a especificação de NOT NULL{:sql} (não nulo), proibindo assim, a inserção de um valor nulo para esse tipo de atributo (obrigatório na PK).

Criar tabela

CREATE TABLE{:sql} define a estrutura de uma tabela, suas restrições de integridade e cria uma tabela vazia.

Sintaxe:

CREATE TABLE nome_tabela (...);

Exemplos:

CREATE TABLE empregado (atributo1 tipo, atributo2 tipo, ...);

CREATE DATABASE EMPRESA;

CREATE TABLE DEPARTAMENTO (
  CodDep SERIAL NOT NULL,
  NomeDepVARCHAR(30),
  PRIMARY KEY (CodDep)
);

CREATE TABLE FUNCIONARIO (
  Matricula INTEGER NOT NULL,
  Nome VARCHAR(30) NOT NULL,
  Salario NUMERIC(8,2),
  Cargo VARCHAR(15) DEFAULT 'Analista',
  Estado CHAR(2),
  Idade INTEGER, CodDepto INT,
  PRIMARY KEY (Matricula),
  FOREIGN KEY (CodDepto) references DEPARTAMENTO (CodDep) ON DELETE
  NO ACTION ON UPDATE NO ACTION
);

Criação de um código que gere códigos automáticos não e padrão SQL, mas caso seja necessario, pode-se utilizar o SERIAL{:sql} na criação do campo. Muito utilizado em relações que possuiem IDs.

Exemplo:

CREATE TABLE cidade (
  id_cidade SERIAL NOT NULL,
  nome_cidade VARCHAR(100) NOT NULL,

  PRIMARY KEY (id_cidade)
);

Remover tabela

DROP TABLE{:sql} remove todos os dados e a própria tabela, estando vazia ou não.

Sintaxe:

DROP TABLE nome_tabela;

Exemplo:

DROP TABLE empregado;

Alterar tabela

ALTER TABLE{:sql} usado para alterar o esquema da tabela, permite modificar a estrutura de uma tabela existente.

Atributos chave não podem ser removidos!

Sintaxe:

ALTER TABLE nome_da_tabela;

1. Sintaxe básica para renomear tabela:

ALTER TABLE <nome da tabela> RENAME TO <novo nome da tabela>;

Ex.:

ALTER TABLE empregado RENAME TO colaborador;

2. Sintaxe básica para inclusão de uma coluna:

ALTER TABLE <nome da tabela> ADD COLUMN <nome da coluna> <domínio e atributos>;

Ex.:

ALTER TABLE funcionario ADD COLUMN identidade VARCHAR(10);

• A instrução ADD COLUMN{:sql} adiciona uma nova coluna com o valor vazio para todas as linhas, isto é, sem nenhum valor armazenado.
• O mesmo acontece quando há a criação de uma tabela (CREATE TABLE{:sql}). A princípio ela não está "povoada" com dados, está vazia, ausente de valores (em outras palavras: não há linhas/tuplas na tabela).
• Os valores para as diversas linhas devem ser adicionadas através de instruções da DML (INSERT INTO).

3. Sintaxe básica para exclusão de uma coluna:

ALTER TABLE <nome da tabela> DROP <nome da coluna>;

Ex.:

ALTER TABLE funcionario DROP identidade;

4. Sintaxe básica para alteração do nome de uma coluna:

ALTER TABLE <nom da tabela> RENAME COLUMN <nome da coluna> TO <novo nome da coluna>;

Ex.:

ALTER TABLE empregado RENAME COLUMN sexo TO genero;

5. Sintaxe básica para alteração do tipo de uma coluna:

ALTER TABLE <nome da tabela> ALTER COLUMN <nome da coluna> TYPE <novo tipo>;

Ex.:

ALTER TABLE funcionario ALTER COLUMN salario TYPE NUMERIC(10,2);

Atributos

Chave Primária PRIMARY KEY{:sql}: É um atributo ou conjunto de atributos que identifica unicamente uma tupla em uma relação. A PK é um atributo ou conjunto de atributos que não pode ter valores repetidos.

Chave Estrangeira FOREIGN KEY{:sql}: É um atributo ou conjunto de atributos que faz referência a uma chave primária ou única em outra tabela. A FK é um atributo ou conjunto de atributos que pode ter valores repetidos.
A FK pode ser declarada com algumas opções de ação para deleção (ON DELETE{:sql}) e atualização (ON UPDATE{:sql}) de registros:

• CASCADE{:sql}
• SET NULL{:sql}
• SET DEFAULT{:sql}
• RESTRICT{:sql}
• NO ACTION{:sql}

Restrição de Atributos (PostgreSQL):

• NOT NULL{:sql} - NN - O valor não pode ser nulo.
• DEFAULT <valor>{:sql} - O valor padrão para o atributo caso não seja passado.
• UNIQUE{:sql} - O valor não pode ser repetido, deve ser único.

Cláusulas da FK

ON DELETE

Cascata - CASCADE{:sql}

Quando um registro é deletado da tabela referenciada, todos os registros que possuem a chave estrangeira referenciando o registro deletado também são deletados.
Sintaxe:

FOREIGN KEY cpf_cliente REFERENCES Cliente(cpf) ON DELETE CASCADE

Onde cpf_cliente é o atributo da tabela atual e Cliente(cpf) é a tabela e atributo referenciado.

Restrito - RESTRICT{:sql}

Quando um registro é deletado da tabela referenciada, a operação é restringida (da erro), ou seja, não é permitido deletar o registro pai se houver outros registros filhos á referenciando.
Sintaxe:

FOREIGN KEY cpf_cliente REFERENCES Cliente(cpf) ON DELETE RESTRICT

Não faz nada - NO ACTION{:sql} padrão - default

Quando um registro é deletado da tabela referenciada, um erro é exibido, e a operação de DELETE{:sql} é revertida.
Sintaxe:

FOREIGN KEY cpf_cliente REFERENCES Cliente(cpf) ON DELETE NO ACTION

Define como nulo - SET NULL{:sql}

Quando um registro é deletado da tabela referenciada, a chave estrangeira é definida como NULL{:sql}.
Sintaxe:

FOREIGN KEY cpf_cliente REFERENCES Cliente(cpf) ON DELETE SET NULL

Valor Padrão - SET DEFAULT{:sql}

Quando um registro é deletado da tabela referenciada, a chave estrangeira é definida como o valor padrão DEFAULT{:sql}.
Sintaxe:

FOREIGN KEY cpf_cliente REFERENCES Cliente(cpf) ON DELETE SET DEFAULT

ON UPDATE

Restrito - RESTRICT{:sql}

Quando um registro é atualizado na tabela referenciada, a operação é restringida (da erro), ou seja, não é permitido atualizar o registro pai se houver outros registros filhos á referenciando.
Sinatxe:

FOREIGN KEY cpf_cliente REFERENCES Cliente(cpf) ON UPDATE RESTRICT

Define como nulo - SET NULL{:sql}

Quando um registro é atualizado na tabela referenciada de modo que não exista mais a chave primária da tabela alterada, a chave estrangeira é definida como NULL{:sql}.
Sintaxe:

FOREIGN KEY cpf_cliente REFERENCES Cliente(cpf) ON UPDATE SET NULL

Define como padrão - SET DEFAULT{:sql}

Quando um registro é atualizado na tabela referenciada de modo que não exista mais a chave primária da tabela alterada, a chave estrangeira é definida como o valor padrão DEFAULT{:sql}.
Sintaxe:

FOREIGN KEY cpf_cliente REFERENCES Cliente(cpf) ON UPDATE SET DEFAULT

Não faz nada - NO ACTION{:sql} padrão - default

Quando um registro é atualizado na tabela referenciada, de modo que a chave primária referenciada não exista mais, um erro é exibido, e a operação de UPDATE{:sql} é revertida.
Sintaxe:

FOREIGN KEY cpf_cliente REFERENCES Cliente(cpf) ON UPDATE NO ACTION

Constraits

Constraits são todas as restrições que uma coluna pode ter (PRIMARY KEY{:sql}, FOREIGN KEY{:sql}, NOT NULL{:sql}, UNIQUE{:sql}, etc).

Adicionar constrait

Quando preciso adicionar uma constrait em uma coluna de uma tabela já criada.

Sintaxe

ALTER TABLE <nome da tabela> ADD CONSTRAINT <nome da restrição> UNIQUE;

ALTER TABLE usuario ADD CONSTRAINT email_unico UNIQUE (email);

ALTER TABLE <nome da tabela> ALTER COLUMN <nome da coluna> SET NOT NULL;

ALTER TABLE usuario ALTER COLUMN email SET NOT NULL;

ALTER TABLE <nome da tabela> ALTER COLUMN <nome da coluna> SET DEFAULT <valor padrão>;

ALTER TABLE usuario ALTER COLUMN email SET DEFAULT '--';

Removendo uma constrait

Quando é necessário remover uma restrição de uma coluna.

Sintaxe

ALTER TABLE <nome da tabela> DROP CONSTRAINT <nome da restrição>;

ALTER TABLE usuario DROP CONSTRAINT email_unico;

ALTER TABLE <nome da tabela> ALTER COLUMN <nome da coluna> DROP NOT NULL;

ALTER TABLE usuario ALTER COLUMN email DROP NOT NULL;

ALTER TABLE <nome da tabela> ALTER COLUMN <nome da coluna> DROP DEFAULT;

ALTER TABLE usuario ALTER COLUMN email DROP DEFAULT;

Schemas

Schemas são conjuntos de tabelas dentro do banco de dados. Por padrão, o PostgreSQL cria um schema chamado public, onde todas as tabelas são armazenadas inicialmente. Porém é possível criar schemas personalizados para organizar melhor as tabelas.

Criar schemas

CREATE SCHEMA <nome_do_schema>;

Exemplo:

CREATE SCHEMA empresa;

Criar tabela em um schema

CREATE TABLE <nome_do_schema>.<nome_da_tabela> (...);

Exemplo:

CREATE TABLE empresa.departamento (cod_dep SERIAL, nome_dep VARCHAR(30));

Toda vez que for necessário referenciar uma tabela em um schema específico, deve-se informar o nome do schema seguido de um ponto .{:sql} antes do nome da tabela.

Isso não ocorre quando a tabela está no schema padrão public. Se não passarmos o nome do schema, o PostgreSQL entende que a tabela está no schema public.

Remover schemas

DROP SCHEMA <nome_do_schema>;

Exemplo:

DROP SCHEMA empresa;

Remover base de dados (DB)

DROP remove toda a base de dados, incluindo todas as tabelas, dados, índices, etc.

Sintaxe:

DROP DATABASE nome_do_banco;

Exemplo:

DROP DATABASE Empresa;
DROP DATABASE Hospital;
DROP DATABASE Universidade;

DML - Data Manipulation Language

DML - Data Manipulation Language (Linguagem de Manipulação de Dados) é usada para gerenciar os dados armazenados em um banco de dados. Manipula os dados de uma tabela, como inserir, atualizar, excluir e selecionar.

Propriedades

A linguagem DML é composta por 4 operações de manipulação de dados:

• Inserção de dados - INSERT{:sql}
• Exclusão de dados - DELETE{:sql}
• Atualização de dados - UPDATE{:sql}
• Seleção de dados (consulta) - SELECT{:sql}

Inserir Dados

INSERT INTO{:sql} é usado para inserir novos registros em uma tabela.

Sintaxe:

INSERT INTO <nome da tabela> (coluna1, coluna2, ...) VALUES (valor1, valor2, ...);

Exemplo:

INSERT INTO empregado (nome, salario, cargo) VALUES ('João', 2000.00, 'Analista');

Por exemplo, se criarmos a tabela seguindo a ordem nome-salario-cargo:

CREATE TABLE empregado (
  nome VARCHAR(30),
  salario NUMERIC(8,2),
  cargo VARCHAR(15)
);

Poderemos inserir omitindo a lista de atributos, dês de que os valores estejam na ordem correta:

INSERT INTO empregado VALUES ('João', 2000.00, 'Analista');

INSERT INTO empresa.empregado VALUES ('João', 2000.00, 'Analista');

Excluir Dados

DELETE FROM{:sql} é usado para excluir registros (tupla/linha) de uma tabela (relação).

Sintaxe:

DELETE FROM nome_tabela WHERE condicao;

Exemplo:

DELETE FROM peca WHERE cod_peca = 200;

Atualizar dados

UPDATE{:sql}/SET{:sql} é usado para atualizar registros existentes em uma tabela. Quando há mudança de endereço, nome, etc...

Sintaxe:

UPDATE nome_tabela SET coluna1 = valor1, coluna2 = valor2 WHERE condicao;

Exemplo:

UPDATE peca SET preco = 90.00 WHERE cod_peca = 200;

Selecionar dados

SELECT{:sql} é usado para selecionar dados de um banco de dados. A instrução SELECT{:sql} é usada para recuperar registros de uma ou mais tabelas.

Sintaxe:

SELECT coluna1, coluna2, ... FROM nome_tabela WHERE condicao;

Exemplo:

SELECT nome_peca, quantidade FROM peca WHERE preco > 50;

SELECT * FROM peca;

Cláusula WHERE (condição)

A cláusula WHERE{:sql} é usada para filtrar registros. A cláusula WHERE{:sql} é usada para extrair apenas os registros que atendem a uma condição específica.

Usa conectores lógicos:

• AND{:sql} - E
• OR{:sql} - OU
• NOT{:sql} - NÃO

Usa operadores de comparação:

• >{:sql} - Maior
• <{:sql} - Menor
• ={:sql} - Igual
• <={:sql} - Menor ou igual
• >={:sql} - Maior ou igual
• !={:sql} - Diferente (ou <>{:sql})
• BETWEEN{:sql} - Entre um intervalo (incluindo os extremos). Facilita a especificação de condições númericas que envolvam um intervalo, ao invés de usar os operadores <={:sql} e >={:sql}.

Exemplos

Iremos fazer algumas operações de busca SELECT{:sql} usando cláusulas de condição/filtro WHERE{:sql} na tabela abaixo:

EXEMPLO 1 - Selecionar o código e o nome das peças com o preço menor que $70.00$

SELECT cod_peca, nome_peca FROM peca WHERE preco < 70.00;

Resultado:

EXEMPLO 2 - Selecionar o nome e o preço das peças com preço maior que $50.00$ e menor do que $70.00$

SELECT nome_peca, preco WHERE preco BETWEEN 50.00 AND 70.00

Resultado:

EXEMPLO 3 - Selecionar todas as informações das peças cuja quantidade em estoque seja maior ou igual a $10$.

SELECT * FROM peca WHERE qtd >= 10;

Resultado:

EXEMPLO 4 - Selecionar o código, nome, preço e quantidade de peças no estoque cujo código é $200$.

SELECT cod_peca, nome_peca, preco, qtd FROM peca WHERE cod_peca = 200;

Resultado:

EXEMPLO 5 - Selecionar o nome e a quantidade de todas as peças que há no estoque.

SELECT nome_peca, quantidade FROM peca WHERE qtd != 0;

ou...

SELECT nome_peca, quantidade FROM peca WHERE qtd <> 0;

Resultado:

Cláusula ORDER BY (ordenação)

A cláusula ORDER BY{:sql} é usada para ordenar o resultado de uma consulta em ordem crescente ou decrescente. Ela é aplicada somente à operações de consulta SELECT{:sql}, após a cláusula WHERE{:sql}.

Para especificar a forma de ordenação, devemos indicar

• ASC{:sql} - Crescente padrão - default
• DESC{:sql} - Decrescente

Sintaxe:

SELECT coluna1, coluna2, ... FROM nome_tabela WHERE condicao ORDER BY coluna ASC|DESC;

Exemplo:

SELECT nome_peca, quantidade FROM peca ORDER BY nome_peca DESC;

Resultado:

Funções de agregação

As funções de agregação são usadas para calcular algo a partir de um conjunto de valores. As funções de agregação são usadas com a cláusula SELECT{:sql}.

As principais são:

• COUNT{:sql} - Conta o número de linhas (tuplas)
• SUM{:sql} - Soma os valores da coluna - apenas em dados numéricos
• AVG{:sql} - Calcula a média dos valores da coluna (average³) - apenas em dados numéricos
• MIN{:sql} - Retorna o menor valor da coluna
• MAX{:sql} - Retorna o maior valor da coluna

EXEMPLO 1 - Encontrar a soma dos preços de todas as peças, o maior preço, o menor preço e a média dos preços.

SELECT SUM(preco), MAX(preco), MIN(preco), AVG(preco) FROM peca;

Resultado:

EXEMPLO 2 - Contar o número de peças que há no estoque.

SELECT COUNT(*) FROM peca;

ou

SELECT COUNT(cod_peca) FROM peca;

Resultado:

Cláusula DISTINCT (linhas únicas)

Linhas duplicadas podem aparecer nas relações. No caso de desejarmos a eliminação de duplicidade, devemos inserir a palavra DISTINCT{:sql} na cláusula SELECT{:sql}.

Tabela neste momento:

SELECT * FROM peca;

Sinatxe:

SELECT DISTINCT coluna1, coluna2, ... FROM nome_tabela;

Exemplo:

Selecionar o nome de todas as peças, sem o DISTINCT{:sql}:

SELECT nome_peca FROM peca;

Selecionar o nome de todas as peças, com o DISTINCT{:sql}:

SELECT DISTINCT nome_peca FROM peca;

Cláusula GROUP BY (agrupar)

A cláusula GROUP BY{:sql} é usada para agrupar linhas que possuem o mesmo valor em uma ou mais colunas. É normalmente usada em conjunto com funções de agregação para agrupar os resultados de acordo com um ou mais campos. Desta forma, as funções de agregação será aplicada a cada grupo, e não a todas as tuplas.

Tabela neste momento:

SELECT * FROM peca ORDER BY nome_peca;

Sintaxe:

SELECT coluna1, coluna2, ... FROM nome_tabela GROUP BY coluna1, coluna2, ...;

EXEMPLO 1 - Selecionar o nome de todas as peças e agrupar por veículo (contar por grupo):

SELECT veiculo, COUNT(1) FROM peca GROUP BY veiculo;

Resultado:

EXEMPLO 2 - Obter a soma da quantidade de peças por tipo de veículo

SELECT veiculo, SUM(qtd) FROM peca GROUP BY veiculo;

Resultado:

Cláusula HAVING (filtro)

A cláusula HAVING{:sql} é usada para filtrar grupos de registros que resultam de uma operação de GROUP BY{:sql}. A cláusula HAVING{:sql} é usada em conjunto com a cláusula GROUP BY{:sql}.

Sintaxe:

SELECT coluna1, coluna2, ... FROM nome_tabela GROUP BY coluna1, coluna2, ... HAVING condicao;

EXEMPLO 2 anterior (alterado) - Obter a soma da quantidade de peças por tipo de veículo que sejam maiores que 20

SELECT veiculo, SUM(qtd) FROM peca GROUP BY veiculo HAVING SUM(qtd) > 20;

Resultado:

Seleção com Junção

As vezes queremos retornar dados de mais de uma tabela, relacionando os dados de uma tabela com os dados de outra.

Para fazer a junção das tabelas, precisamos definir uma condição de junção, na qual os atributos chave primária (primary key) e chave estrangeira (foreign key) das relações devem ser relacionados.

Tabelas de exemplo

Exemplo 1: Obter os nomes dos técnicos com experiência em secadora.

Query

SELECT nome FROM tecnicos, experiencia
WHERE num_tec = num_tecnico AND tipo = 'Secadora';

Resultado

| Nome  |
|-------|
| Hélio |
| Tião  |

Exemplo 2: Listar o nome dos técnicos e sua experiência em aparelhos da categoria 1

Query

SELECT tecnicos.nome, experiencia.anos_exp, tipos.tipo
FROM tecnicos, tipos, experiencia
WHERE
  tipos.tipo = experiencia.tipo
AND
  experiencia.num_tecnico = tecnicos.num_tec
AND
  tipos.categoria = 1

SELECT tecnicos.nome, experiencia.anos_exp, tipos.tipo
FROM tecnicos, tipos, experiencia
WHERE
  tipos.tipo = experiencia.tipo
AND
  experiencia.num_tecnico = tecnicos.num_tec
AND
  tipos.categoria = 1

Resultado

|  nome  | anos_exp |   tipo    |
|--------|----------|-----------|
| Hélio  |    15    | Secadora  |
| Tião	 |    18    | Lavadora  |
| Marco	 |    1     | Secadora  |
| Sílvio |    5     | Lavadora  |
| Tião	 |    12    | Secadora  |

Uso de aliases (apelido)

Alias são apelidos que podemos dar aos atributos na hora de retornar valores no SELECT{:sql}, permite associar um "nome de variável" para cada relação, a fim de simplificar comandos SQL, e torna o retorno mais legível.

Para criarmos um alias podemos usar a palavra reservada AS{:sql}. Criando um SELECT{:sql} com alias temos:

Alias para tabelas

SELECT T.nome, E.anos_exp, TP.tipo
FROM
  tecnicos AS T,
  tipos AS TP,
  experiencia AS E
WHERE TP.tipo = E.tipo
  AND E.num_tecnico = T.num_tec
  AND TP.categoria = 1;

Alias para atributos

SELECT
  tecnicos.nome AS Tecnico,
  experiencia.anos_exp AS Experiencia,
  tipos.tipo AS Tipo
FROM tecnicos, tipos, experiencia
WHERE tipos.tipo = experiencia.tipo
  AND experiencia.num_tecnico = tecnicos.num_tec
  AND tipos.categoria = 1;

nome | anos_exp | tipo         Tecnico | Experiencia | Tipo
-----|----------|------        --------|-------------|------
 ... |   ...    |  ...           ...   |     ...     |  ...
 ... |   ...    |  ...    ->     ...   |     ...     |  ...
 ... |   ...    |  ...           ...   |     ...     |  ...
 ... |   ...    |  ...           ...   |     ...     |  ...

Limitando o número de linhas

Em alguns casos, é necessário limitar o número de linhas retornadas em uma consulta. Para isso, podemos usar a cláusula LIMIT{:sql}.

Sintaxe:

SELECT coluna1, coluna2, ... FROM <tabela> LIMIT <número de linhas>;

Exemplo:

SELECT * FROM peca LIMIT 5;

Pulando linhas

Podemos também pular um número de linhas no início da consulta, usando a cláusula OFFSET{:sql}.

Sintaxe:

SELECT coluna1, coluna2, ... FROM <tabela> OFFSET <número de linhas>;

Exemplo:

SELECT * FROM peca ORDER BY nome OFFSET 3;

Comando LIKE

Quando desejamos pesquisar uma substring de um texto, podemos usar o comando LIKE{:sql} ou NOT LIKE{:sql}. Ele é usado para comparar um valor de texto com um padrão.

Utilizamos o sinal %{:sql} para representar zero ou mais caracteres e o sinal de _{:sql} para representar um único caractere.

Sintaxe:

SELECT coluna1, coluna2, ... FROM <tabela> WHERE coluna LIKE <padrão>;

Exemplo

Imagine que temos a seguinte tabela no banco de dados:

E queremos retornar todoas as pessoas que possuem a letra e no nome.

SELECT * FROM pessoa WHERE nome LIKE '%e%';

Resultado:

cod_pessoa | nome            | data_nasc    | profissao
-----------|-----------------|--------------|-----------
3          | Legolas         | 87 - 3ª era  | Arqueiro
4          | Elliot          | 1985-09-17   | Engenheiro de segurança
5          | Harvy Specter   | 1972-03-12   | Advogado

Valores condicionais (CASE)

O comando CASE{:sql} é uma expressão condicional que retorna um valor único com base em uma ou mais condições. Ele é usado para substituir valores de uma coluna por outro valor, com base em uma condição.

Sintaxe:

SELECT coluna1, coluna2, ...,
  CASE
    WHEN condicao1 THEN valor1
    WHEN condicao2 THEN valor2
    ELSE valor_padrao
  END
FROM <tabela>;

Exemplo

SELECT
  nome,
  idade,
  CASE
    WHEN idade < 30 THEN 'Jovem'
    WHEN idade < 60 THEN 'Adulto'
    WHEN idade < 200 THEN 'Idoso'
    ELSE 'Imortal'
  END AS faixa_etaria
FROM pessoa;

nome           | idade | faixa_etaria
---------------|-------|-------------
Elliot         | 36    | Adulto
Tony Stark     | 51    | Adulto
Legolas        | 300   | Imortal
Gustavo Fring  | 64    | Idoso
Robbin         | 25    | Jovem

Observações

Uma consulta em SQL pode consistir em até seis cláusulas:

SELECT [*] [DISTINCT] <lista de atributos> <funções de agregação>
FROM <lista de tabelas>
[WHERE <condição>]
[GROUP BY <lista de atributos para agrupamento>]
[HAVING <condição para agrupamento, aceita funções de agregação>]
[ORDER BY <lista de atributos para ordenação>] [ASC] [DESC]

• Apenas as cláusulas SELECT{:sql} e FROM{:sql} são obrigatórias
• Quando existentes, as cláusulas devem aparecer na ordem específica acima.
• O ORDER BY{:sql} só pode ser ultilizado após o último SELECT{:sql} (se a linguagem permitir)
• As cláusulas GROUP BY{:sql} e HAVING{:sql} só podem ser usadas nos comandos SELECT{:sql} individuais

Retornando dados alterados

Em alguns caso, é necessário retornar dados que foram alterados (inseridos, atualizados, deletados). Para isso podemos usar a cláusula RETURNING{:sql} ao final da nossa query de alteração.

Sintaxe:

INSERT INTO <nome da tabela> (...) VALUES (...) RETURNING coluna1, coluna2, ...;

Exemplo:

INSERT INTO peca (nome_peca, preco, qtd)
VALUES ('Peça H', 10.00, 5)
RETURNING cod_peca;

UPDATE peca SET preco = 90.00
WHERE cod_peca = 200
RETURNING nome_peca;

DELETE FROM peca WHERE cod_peca = 200 RETURNING nome_peca;

A sintaxe do RETURNING{:sql} é a mesma que a do SELECT{:sql}, ou seja, podemos retornar qualquer coluna da tabela que foi alterada.

Valores NULL (nulo)

Suponhamos que temos a tabela Peça criada anteriormente, estruturada e preenchida da seguinte forma:

CREATE TABLE peca (
  cod_peca INTEGER NOT NULL,
  nome_peca VARCHAR(30) NOT NULL,
  preco NUMERIC(6,2),
  qtd INTEGER DEFAULT 0
);

INSERT INTO peca VALUES
  (1, 'Peça A', 15.00, 10),
  (2, 'Peça B', 8.00, 20),
  (3, 'Peça C', 8.00, 30),
  (4, 'Peça D', 8.00, 10);

Inserindo valores nulos

Quando realizamos um INSERT{:sql} e não passamos o campo, o banco de dados vai automaticamente inserir NULL{:sql} no valor da célula.

INSERT INTO peca (cod_peca, nome_peca, qtd) VALUES (5, 'Peça E', 15);

Resultado:

Lembre-se que colunas que tem o valor DEFAULT{:sql} definido, não serão preenchidas com NULL{:sql}, mas sim com o valor DEFAULT{:sql} especificado no momento da criação da tabela.

INSERT INTO peca (cod_peca, nome_peca, preco) VALUES (6, 'Peça F', 20.00);

Resultado:

Existe um outra forma de definir um valor como NULL{:sql}. Deixando explícito no comando INSERT{:sql} que a coluna deve receber o valor NULL{:sql}.

INSERT INTO peca (cod_peca, nome_peca, preco, qtd) VALUES (7, 'Peça G', 17.00, NULL);

Resultado:

Repare que mesmo o campo qtd possuindo um valor DEFAULT{:sql}, foi definido de forma explícita no INSERT{:sql} que essa coluna deveria possuir um valor NULL.

INSERT INTO peca (cod_peca, nome_peca, preco, qtd) VALUES (7, NULL, 17.00, 12);

Resultado:

ERROR:  null value in column "nome_peca" of relation "peca" violates not-null constraint
DETAIL:  Failing row contains (7, null, 17.00, 12).
SQL state: 23502

Selecionando valores nulos

Caso você queira selecionar somente as linhas com valores nulos em uma determinada célula, a forma correta é utilizar o IS NULL{:sql}, e não ... = NULL{:sql}.

SELECT * FROM peca WHERE preco IS NULL;

SELECT * FROM peca WHERE preco = NULL;

Selecionando valores não nulos

Caso você queira selecionar apenas as linhas que não possuem valores nulos em uma determinada coluna, é só utilizar o c omando IS NOT NULL{:sql}.

SELECT * FROM peca WHERE preco IS NOT NULL;

Resultado:

Repare que a peça de código $5$ não foi incluída no resultado, por possuir o valor null na coluna preco.

Ordenando colunas com NULL

Por default, caso você ordene um SELECT{:sql} por uma coluna que possui células com valor NULL{:sql}, essas células serão as últimas a serem retornadas.

SELECT * FROM peca ORDER BY preco;

Resultado:

Caso você deseje que as células com valores NULL{:sql} sejam as primeiras a serem retornadas no SELECT{:sql}, utilizamos o ORDER BY ... NULLS FIRST{:sql}.

SELECT * FROM peca ORDER BY preco NULLS FIRST;

Resultado:

Substituindo valores nulos

Em alguns casos é necessário substituir os valores NULL{:sql} por outro valor, quando usarmos o SELECT{:sql} ou o RETURNIG{:sql}. Para isso, podemos usar a função COALESCE{:sql}.

Sintaxe

SELECT COALESCE(<coluna>, <valor substituido>) FROM <tabela>;

Exemplo:

SELECT codigo, telefone FROM professor;

| codigo | telefone |
|--------|----------|
|   1    | 37999999 |
|   2    | [null]   |

SELECT codigo, COALESCE(telefone, 'NÃO CADASTRADO') FROM professor;

| codigo | telefone       |
|--------|----------------|
|   1    | 37999999       |
|   2    | NÃO CADASTRADO |

Junções (Comando JOIN)

Junção é a possibilidade de se criar relacionamentos entre tabelas, de forma a poder recuperar dados de mais de uma tabela em uma única consulta. Um jeito melhor e nativo de se juntar mais de uma tabela, diferente do método apresentado no capítulo Seleção com Junção.

Isso é possível atravez do comando JOIN{:sql} (junção), que é usado para combinar linhas de duas ou mais tabelas com base em uma relação entre elas, e recuperando esses dados usando apenas um SELECT{:sql}.

É importante utilizá-lo, porque tira da cláusula WHERE{:sql} condições que são estritamente das junções (chave primária igual a chave estrangeira, por exemplo).

Existem as variações de junções internas e externas.

Internas: INNER JOIN{:sql} e NATURAL JOIN{:sql}
Externas: OUTER JOIN{:sql} (LEFT{:sql}, RIGHT{:sql}, FULL{:sql})

Como funciona o comando JOIN{:sql}?

Quando um comando SELECT{:sql} especifica campos de duas tabelas sem nenhumas restrição ou filtro, o resultado será um número de linhas iguais à multiplicação do total de linhas da primeira tabela ($N$) pela segunda tabela ($M$), ou seja $M\times N$.

Isso ocorre devido ao fato de que, para cada linha da primeira tabela, todas as linhas da segunda são processadas. Operações de junção toma duas relações, e têm como resultado uma outra relação.

Porém, o benefício do JOIN{:sql} só será sentido quando as chaves $PK$ e $FK$ forem equivalentes, ou seja, $id = id\_curso$, usando a palavra reservada ON{:sql} (será explicado mais a frente).

A operção de junção tem algumas variantes, e cada uma dessas variações consiste em um tipo de junção e uma condição de junção.

Sintaxe

SELECT coluna1, coluna2, ...
FROM tabela1 <tipo> JOIN tabela2
ON <condição>;

Exemplo

SELECT nome, nasc, experiencia
FROM tecnicos INNER JOIN experiencia
ON tecnicos.num_tec = experiencia.num_tecnico;

TIPO DE JUNÇÃO (INNER{:sql} ou OUTER{:sql})
Define como as tuplas em cada relação que não possuam nenhuma conrrespondência com as tuplas da outra relação deve ser tratadas.

CONDIÇAO DE JUNÇAO (ON{:sql})
Definem quais tuplas das duas relações apresentam correspondência e quais atributos são apresentados de uma junção.

INNER JOIN

O INNER JOIN{:sql} (Ou somente JOIN{:sql}) é uma junção interna, que junta os registros de uma tabela que tiver um correspondente na outra tabela, através da chave primária e estrangeira.

Por exemplo, a tabela abaixo é resultado de um JOIN{:sql} de 2 outras tabelas. A segunda tabela possui chaves estrangeiras apontando para valores nulos, e a primeira possui tuplas sem conrrespondência na segunda tabela. O resultado do INNER JOIN{:sql} será apenas as linhas que possuem corrêspondência nas duas tabelas:

Sintaxe

SELECT coluna1, coluna2, ...
FROM (tabela1 INNER JOIN tabela2
      ON tabela1.chave_primaria = tabela2.chave_estrangeira);

SELECT coluna1, coluna2, ...
FROM (tabela1 JOIN tabela2
      ON tabela1.chave_primaria = tabela2.chave_estrangeira);

Usando o INNER JOIN com 2 tabelas

Exemplo: Liste o nome dos técnicos que possuem experiência em Lavadora

Tabelas

Query

SELECT nome
FROM (tecnicos INNER JOIN experiencia
      ON tecnicos.num_tec = experiencia.num_tecnico)
WHERE experiencia.tipo = 'Lavadora';

Resultado

Usando o INNER JOIN com 3 tabelas

Exemplo: Liste o nome dos técnicos e sua experiência em aparelhos da categoria 1

Tabelas

Query

SELECT nome, anos_exp
FROM ((tecnicos INNER JOIN experiencia
       ON num_tec = num_tecnico) INNER JOIN Tipos
       ON tipo = tipo)
WHERE categoria = 1;

Resultado

NATURAL JOIN

Com ele você não precisa identificar quais colunas serão comparadas, pois ele fará a comparação entre campos com o mesmo nome.

Sintaxe

SELECT coluna1, coluna2...
FROM tabela1 NATURAL JOIN tabela2;

Exemplo

SELECT * FROM (tecnicos NATURAL JOIN experiencia);

Repare que não precisamos passar a condição de junção com ON{:sql}, já que ambas as tabelas possuem a coluna tipo.

O mesmo não da pra ser feito entre as tabelas tecnicos e tipos, pois não possuem colunas com o mesmo nome.

OUTER JOIN

O OUTER JOIN{:sql} é a variação de junção externa, e é composto por 3 tipos:

• LEFT OUTER JOIN{:sql}
• RIGHT OUTER JOIN{:sql}
• FULL OUTER JOIN{:sql}

Diferente das junções internas, como o INNER JOIN{:sql}, as junções externas podem retornar valores mesmo quando não há conrrespondência entre as tabelas (valores NULL{:sql}).

LEFT OUTER JOIN

No LEFT OUTER JOIN{:sql} (ou simplesmente LEFT JOIN{:sql}), a prioridade é da tabela da esquerda, isto é, todos os registros da primeira tabela serão mostrados independente se houver correspondente nas outra tabela, após a equivalência das chaves usando o ON{:sql}.

Sintaxe

SELECT coluna1, coluna2...
FROM tabela1 LEFT OUTER JOIN tabela2;

Exemplo

SELECT * FROM (tecnicos LEFT OUTER JOIN experiencia);

RIGHT OUTER JOIN

No RIGHT OUTER JOIN{:sql} (ou simplesmente RIGHT JOIN{:sql}), a prioridade é da tabela da direita, isto é, todos os registros da segunda tabela serão mostrados independente se houver correspondente na outra tabela.

Pega todos os atributos da relação que está à direita, verifica se existe algum correspondente à esquerda, caso afirmativo, retorna os atributos da esquerda, e caso negativo, coloca o valor nulo nos atributos.

Sintaxe

SELECT coluna1, coluna2...
FROM tabela1 RIGHT OUTER JOIN tabela2;

Exemplo

SELECT * FROM (tecnicos RIGHT OUTER JOIN experiencia);

FULL OUTER JOIN

Faz o RIGHT{:sql} e o LEFT{:sql} ao mesmo tempo, ou seja, vai retornar dados que não tem em comum nas duas tabelas, e não só na tabela da direita ou da esquerda.

Sintaxe

SELECT coluna1, coluna2...
FROM tabela1 FULL OUTER JOIN tabela2;

Exemplo

SELECT * FROM (tecnicos FULL OUTER JOIN experiencia);

Funções Matemáticas

Funções de String

Conversão de dados

Existem alguns métodos para se converter um tipo de um dado em outro. O mais comum é utilizando a função CAST{:sql}, que converte um valor de um tipo de dado para outro.

Sinatxe

CAST(valor AS tipo_de_dado);

Onde valor é o valor que será convertido e tipo_de_dado é o tipo para o qual o valor será convertido. Exemplo:

CAST('5' AS NUMERIC);

Repare que no exemplo acima, '5' está como string por causa das aspas simples ', e queremos converter para um inteiro.

O mesmo pode ser feito utilizando a sintaxe valor::tipo{:sql}, onde valor é o valor que será convertido e tipo é o tipo para o qual o valor será convertido. Exemplo:

5::TEXT;

Aqui, 5 está como inteiro, e estamos convertendo para o formato texto (string).

Formato de dados

to_char ( timestamp, formato ) → texto
to_char ( timestamp com fuzo horário, formato ) → texto

to_char(timestamp '2002-04-20 17:31:12.66', 'HH12:MI:SS') → 05:31:12

to_char ( intervalor, formato ) → texto

to_char(interval '15h 2m 12s', 'HH24:MI:SS') → 15:02:12

to_char ( numeric_type, text ) → text

to_char(125, '999') → 125
to_char(125.8::real, '999D9') → 125.8
to_char(-125.8, '999D99S') → 125.80-

to_char ( numeric_type, text ) → text

to_char(125, '999') → 125
to_char(125.8::real, '999D9') → 125.8
to_char(-125.8, '999D99S') → 125.80-

to_date ( texto, data ) → data

to_date('05 Dec 2000', 'DD Mon YYYY') → 2000-12-05

to_number ( texto, formato ) → numero

to_number('12,454.8-', '99G999D9S') → -12454.8

to_timestamp ( texto, formato ) → timestamp com fuso horário

to_timestamp('05 Dec 2000', 'DD Mon YYYY') → 2000-12-05 00:00:00-05

Introdução

Em projetos de banco de dados, a modelagem de dados é feita através de um modelo de dados conceitual, geralmente o Modelo Entidade-Relacionamento (MER) que representa o esquema das visões e de toda a base de dados, especificados em diagramas ER.

O passo seguinte à modelagem dos dados é o mapeamento do diagrama da base de dados, obtido na fase anterior, para um modelo de dados lógico, o Modelo Relacional (MR), representado por meio de tabelas.

Para isso, considere o esquema ER mostrado a seguir, que será utilizado para ilustrar o procedimento de mapeamento. Este procedimento é apresentado passo-a-passo, a partir do exemplo do MER de uma empresa.

Regras

Passo 1: Entidade

Para cada entidade criar uma relação (Tabela) que inclua todos os atributos simples, para atributos compostos, inclua apenas os atributos simples que compõem o atributo composto. Escolha um dos atributos-chave da entidade para constituir a chave primária da relação (se a chave escolhida for composta, então o conjunto de atributos simples que a compõem irão formar a chave primária da relação).

No exemplo, foram criadas as relações EMPREGADO e PROJETO, correspondentes às entidades EMPREGADO e PROJETO, presentes no diagrama ER.

Os atributos indicados com chave-estrangeira (*) não foram incluídos ainda; eles serão adicionados durante os passo subsequentes.

NOTAÇAO TEXTUAL

EMPREGADO (EmpNome, DataNasc, CPF, Sexo, Rua, Cidade, Estado, Salário)
PROJETO (ProjNome, ProjNúmero, ProjLocalização)

Passo 2: Atributo multivalorado

Para cada atributo multivalorado, criar uma nova relação que inclua o atributo simples como chave-primária. A relação também deve ter como atributo a chave-primária da relação que representa o atributo multivalorado. A chave-primária da relação será então a combinação das duas chaves.

No exemplo foi criado a relação LOCAL_DEPTO. O atributo "Localização" representa o atributo multivalorado Localização de DEPARTAMENTO, enquanto DeptoNúmero - como chave estrangeira - representa a chave-primária da relação DEPARTAMENTO. A chave primária de LOCAIS_DEPTO é a combinação de { DeptoNúmero, Localização }.

NOTAÇAO TEXTUAL

DEPARTAMENTO (DeptoNome, DeptoNúmero)
LOCAL_DEPTO (DeptoNúmero*, Localização)

Passo 3: Entidade Fraca

Para cada entidade fraca, criar uma relação e incluir todos os atributos simples (ou os componentes simples de atributos compostos) como atributos da relação. Além disso, incluir como chave-estrangeira a chave-primária da relação que corresponde ao tipo de entidade dependente. A chave-primária então é a combinação da chave da entidade "forte" e a chave parcial do tipo de entidade fraca.

No exemplo, foi criada a relação DEPENDENTE correspondente ao tipo de entidade fraca DEPENDENTE. Foi incluída a chave-primária da relação EMPREGADO como atributo de DEPENDENTE (chave estrangeira). A chave-primária da relação DEPENDENTE é a combinação { EmpCPF*, DependNome }, porque DependNome é a chave-parcial da entidade DEPENDENTE.

NOTAÇAO TEXTUAL

DEPENDENTE (EmpCPF*, DependNome, DependSexo, DepDTNasc, RelacaoParente)

Passo 4: Relacionamento 1:1

Para cada tipo de relacionamento 1:1 (um para um), a chave de uma das entidades participantes do relacionamento, vira atributo de outra entidade (como chave estrangeira da relação). Caso o relacionamento tenha atributo(s), este(s) também será(ão) incluídos como atributos na entidade escolhida.

Exemplo: foi mapeado o tipo de relacionamento 1:1 GERENCIA, escolhendo a entidade participante DEPARTAMENTO (porque sua participação no tipo de relacionamento GERENCIA é total, já que todo o departamento tem um gerente). Foi incluída a chave-primária da relação EMPREGADO como a chave-estrangeira na relação DEPARTAMENTO, chamada de EmpCPFGerente. Também foi incluído o atributo simples DataInício do tipo de relacionamento GERENCIA na relação DEPARTAMENTO, nomeado como DataInicioGerencia.

EMPREGADO (EmpNome, DataNasc, CPF, Sexo, Rua, Cidade, Estado, Salário)
DEPARTAMENTO (DeptoNome, DeptoNúmero, EmpCPFGerente*, DataInicioGerencia)

Passo 5: Relacionamento 1:N

Para cada relacionamento 1:N (um para muitos), a chave da entidade participante do relacionamento com cardinalidade "1" vra atributo da entidade com cardinalidade "N". Isto é, incluir como chave-estrangeira da relação N, a chave-primária da relação 1 (isto porque cada instância da entidade do lado 1 está relacionada a mais de uma instância do lado N do relacionamento). Inclua também quaisquer atributos simples do tipo de relacionamento 1:N como atributos da entidade do lado "N".

Exemplo: Foram mapeados os tipos de relacionamento 1:N, CONTROLA, SUPERVISIONA e TRABALHA_PARA.
Para CONTROLA incluiu-se a chave-primária da relação DEPARTAMENTO como a chave estrangeira na relação PROJETO, e foi chamado DeptoNum.
Para SUPERVISIONA, incluiu-se a chave-primária da relação EMPREGADO como a chave-estrangeira na relação EMPREGADO, e foi denomido NumCPFSuper.
No relacionamento TRABALHA-PARA, foi incluída a chave-primária da relação DEPARTAMENTO como a chave-estrangeira na relação EMPREGADO, e foi denominado DeptoNum.

DEPARTAMENTO (DeptoNome, DeptoNúmero, EmpCPFGerente, DataInicioGerencia)
PROJETO (ProjNome, ProjNúmero, ProjLocalização, DeptoNum*)
EMPREGADO (EmpNome, DataNasc, CPF, Sexo, Rua, Cidade, Estado, Salário, NumCPFSuper*)

EMPREGADO (EmpNome, DataNasc, CPF, Sexo, Rua, Cidade, Estado, Salário, NumCPFSuper*, DeptoNum*)
DEPARTAMENTO (DeptoNome, DeptoNúmero, EmpCPFGerente, DataInicioGerencia)

Passo 6: Relacionamento N:M

Para cada tipo de relacionamento M:N (muitos para muitos), criar uma nova relação. Incluir como chave-estrangeira na nova relação as chaves-primárias das relações que representam os tipos de entidade participantes. As chaves-primárias será a combinação das chaves estrangeiras, neste caso. Inclua também qualquer atributo simples do tipo de relacionamento M:N (ou componentes simples dos atributos compostos) como atributo da nova relação. **Relacionamentos N:M sempre geram uma nova relação.

No exemplo foi mapeado o tipo de relacionamento M:N, TRABALHA_EM criando-se a relação TRABALHA_EM. Incluiu-se as chaves-primárias das relações PROJETO e EMPREGADO como chaves-estrangeiras na relação TRABALHA_EM, chamadas de ProjNúmero e EmpCPF. Também foi incluído o atributo NumHoras para representar o atributo horas do tipo de relacionamento.

A chave-primária da relação TRABALHA_EM é a combinação das chaves-estrangeiras { EmpCPF, ProjNúmero }.

EMPREGADO (EmpNome, DataNasc, CPF, Sexo, Rua, Cidade, Estado, Salário, NumCPFSuper*, DeptoNum*)
PROJETO (ProjNome, ProjNúmero, ProjLocalização, DeptoNum*)
TRABAHA_EM (EmpCPF*, ProjNúmero*, NumHoras)

Modelo Relacional (Resultado)

EMPREGADO (EmpNome, DataNasc, CPF, Sexo, Rua, Cidade, Estado, Salário, NumCPFSuper*, DepNum*)
PROJETO (ProjNome, ProjNumero, ProjLocalização, DeptoNum*)
TRABALHA_EM (EmpCPF*, ProjNúmero*, NumHoras)
DEPARTAMENTO (DeptoNome, DeptoNumero, EmpCPFGerente*, DataInicioGerencia)
DEPENDENTE (DependNome, EmpCPF*, DependSexo, DependDataNasc, Relação)
LOCAL_DEPTO (DeptoNumero*, Localização)

Especialização e Generalização

Vamos agora levar em consideração uma generalização/especialização para converter do MER para MR.

Existem 3 formas de se converter um generalização/especialização de MER para MR:

• Criar uma única tabela para toda a hierarquia de generalização/especialização.
• Criar uma tabela para a entidade genérica e uma tabela para cada entidade especializada.
• Criar uma tabela para cada entidade especializada.

1 - Uma tabela para toda a hierarquia

Você tem uma única tabela para todos os atributos iguais e específicos das entidades anteriores.

Quando tempos a especialização abaixo, podemos ter uma única tabela Cliente com todos os atributos possíveis.

2 - Uma tabela para cada entidade

Você tem a tabela genérica no exemplo acima, Pessoa, e as tabelas especializadas no exemplo Cliente e Funcionário.

As tabelas Funcionário e Cliente recebem uma chave estrangeira da tabela Pessoa.

Essa é uma das melhores formas (lembrar que, não se aplica a todos os cenários) de se modelar uma generalização/especialização, pois, ao invés de cadastrar todos iguais em diferentes tabelas, você cadastra na genérica, e apenas informa a FK na tabela especializada que o registro ficará.

Lembrando que nesta segunda maneira, você cadastra uma Pessoa e ela pode ser tanto cliente quanto funcionário, assim, evitando cadastrar as mesmas informações em duas tabelas diferentes.

3 - Uma tabela para cada entidade especializada

Você tem apenas as tabelas especializadas com os atributos repetidos

Considerações

O principal ponto a ser considerado em um esquema relacional, quando comparado ao esquema do MER, é que os tipos de relacionamento não são representados explicitamente, mas sim através de atributos incluídos em relações pela chave estrangeira.

O número final de relações nem sempre corresponde ao número de entidades do modelo ER, pois além de cada entidade (MER) constituir uma tabela (MR), atributos multivalorados e relacionamentos N:M também geram tabelas no MR.

Sugestão: Siga as etapas na sequência sugerida para realizar o mapeamento. Em caso de dúvidas, volte às etapas anteriores.

Histórico

O Modelo Relacional (MR) foi proposto por Edgar Frank Codd em meados da década de 1970. Se trata de um conceito abstrato que define maneiras de: armazenar, manipular e recuperar dados estruturados.

Fortemente baseada na teoria dos conjuntos, oferecendo assim uma representaão simples e natural da informação.

O modelo relacional representa os dados em um banco de dados como uma coleção de tabela (relações). Cada tabela terá um nome, que será único, e um conjunto de atributos com seus respectivos nomes e domínios.

Esses astributos são as colunas da tabela, todos os valores da coluna são do mesmo tipo de dados.

Conceitos

Relações (tabelas): Os SGBDs relacionais representam os dados sob a forma de TABELAS bidimensionais (linhas x colunas), denominadas RELAÇÕES. É composto por 2 partes:

• Cabeçalho: conjunto fixo de atributos
• Corpo: conjunto variável de tuplas (valor de atributo)

Tuplas: são as linhas da relação (tabela), representam uma instância da relação.

Atributos: são as colunas ou campos da relação (tabela), representam as características da relação.

Célula: A interseção de uma linha x coluna, ou seja, um valor de atributo. Cada célula de uma tabela contém um único valor, característica a qual designa-se por ATOMICIDADE (valor atômico).

Domínio: Conjunto de valores atômicos, a partir do qual, um ou mais atributos extraem seus valores. Por exemplo: o domínio do atributo idade é um número inteiro entre 13 e 70, e o domínio do salário seria um número real entre 953,00 e 5300,00.

Domínio é um conceito semântico, exemplos:

• Peso, qte, valor - São números reais (double, float)
• Nome, Cidade - São caracteres (string/varchar)
• Data de nascimento - São datas (date)

Alguns domínios estão associados a um tipo de dados ou formato. Exemplo:

• CPF: ddd.ddd.ddd-dd onde d = $\{0, 1, 2, ...9\}$ (inteiros)
• Idade Empregado: inteiro entre 18 e 65 ($18 \leq idade \leq 65$)
• Data: dd/mm/aaaa

Descrição física e semântica

Descrição física: serve para identificar o tipo e o formato dos valores que compõem o domínio
Ex.: char(14), "(dd)ddddd-dddd".

Descrição semântica: serve para ajudar na interpretação dos seus valores.
Ex.: Números de telefones da FAPAM

Chaves

As tabelas relacionam-se umas comas outras atravez de chaves. Uma chave é um conjunto de um ou mais atributos que determinam a unicidade de cada registro. As chaves aparece sublinhadas.

Chave candidata: Conjunto de atributos que definem unicamente e minimamente cada tupla em uma relação.
Ex.: Empregado (Código, nome, CPF). Código e CPF são chaves candidatas.

Chave Primária (Primary Key - PK): É uma chave candidata escolhida para identificar unicamente cada tupla em uma relação. O valor deve ser único em cada linha (tupla) da relação.
Ex.: Empregado (Código, nome, CPF). Código foi escolhido como a chave primária.

Chave alternativa: São as chaves candidatas não escolhidas para chave primária.
Ex.: Empregado (Código, nome, CPF). CPF é a chave alternativa.

Chave estrangeira (Foreing Key - FK): É um atributo de uma relação que constitui chave primária de uma outra relação. As chaves estrangeiras funciona como um elo de ligação entre relações (nas operações de consulta/acesso do bando de dados).

A chave estrangeira aparece com o símbolo aterísco após seu nome *.

Exemplo:

• Empregado (CodEmp, NomeEmp, CodDep*)
• Departamento (CodDepto, NomeDep, CodGerente*)

Na relação Empregado, CodEmp é a chave primária e CodDep é a chave estrangeira.
Na relação Departamento, CodDepto é a chave primária e CodGerente é a chave estrangeira, pois o gerente deve estrar cadastrado na tabela Empregados, ou seja, CodDep = CodDepto e CodGerente = CodEmp.

Convenciona-se sublinhar os atributos que compõem a chave primária. Ex.: Empregado (Matrícula, Nome, Endereço, Função, Salário).

Um mesmo atributos pode ter nomes diferentes nas diversas relações em que participa. Exempo:

• Empregado (Matrícula, Nome, Endereço, Função, Salário, NumDep*).
• Departamento (CodDep, Nome, Endereço).

Atributos que representam diferentes conceitos podem ter o mesmo nome. Ex.: Ver os atributos Nome dos exemplos anteriores.

Propriedades

No modelo relacional, podem ser observadas as seguintes propriedades:

A - Uma tabela não deve possuir duas linhas iguais (tuplas duplicadas). Isso se explica pelo fato de que as linhas são componentes de um conjunto (a tabela) e se faz necessário poder distinguir os elementos de um conjunto. Assim, pelomenos um atributo componente da linha deve possuir um valor que a diferencie das demais.

B - Cada tabela ou relação deve possuir um nome prórprio, distinto das demais tabelas do mesmo banco de dados (similar às ENTIDADES, no MER). Ressalta-se que em banco de dados distintos duas tabelas podem ter o mesmo nome.

C - Cada atributo de uma mesma tabela deve possuir um nome diferente (valores de atributos são atômicos, sem repetição, ou seja, ocorrência de apenas um valor de atributo para cada célula da tabela). Por outro lado o mesmo atributo pode aparecer em outra tabela com o mesmo nome ou com nome diferente (sinônimo).

D - Toda tabela de um banco de dados deve possuir chave primária

E - A ordem das linhas e colunas na tabela são inrrelevants (não altera o resultado)

F - Os SGBD-R deve ser capazes de tratar, de maneira diferenciada, o valor NULO (NULL), que indica a ausência de valor para um atributo em determinada linha. Nulo correspode na teoria de conjuntos, o conjunto vazio, e é diferente de zero ou branco. Os atributos podem ter diferentes nulos, sendo que nulo significa inexistência de valor.

Restrições

Condições restritivas do modelo relacional:

A - Restrição de integridade de chave
Toda tupla tem um atributo (ou uma combinação deles) que a identifica de maneira única na relação -> Chave Primária

B - Restrição de integridade de entidade
Nenhum valor da chave primária poderá ser nulo

C - Restrição de integridade referencial

Não são permitidos valores de chave estrangeira em uma relação que não tenham sido cadastrados previamente como chave primária em outra relação.

Em outras palavras, estabelece que um conjunto de atributos de uma relação R1, é uma chave estrangeira se satisfaz as seguintes regras:

• Os atributos da chave estrangeira tem o mesmo domínio dos atributos da chave primária de outra relação R2.
• Um valor da chave estrangeira numa tupla de R1 possui o mesmo valor da chave primária para alguma tupla em R2 ou é NULO.

Exemplo: Empregado (matrícula, nome, salário, m_supervisor*).

Operações de atualização em relações

Considere as seguintes relações:

Inserção

Inserção (Insert): Inserir uma nova tupla na relação.

O que fazer quando detectar uma violação de integridade?

• Rejeitar a inserção
• Tentar corrigir a anomalia para depois inserir

Exclusão

Exclusão (Delete): Remover uma tupla da relação.

O que fazer quando uma violação ocorrer numa remoção?

• Rejeitar a remoção
• Dar o efeito cascata na remoção, removendo todas as tuplas referenciadas por aquela tupla que está sendo removida.
• Modificar os atributos referenciados para novos valores ou nulos (caso não façam parte da chave primária).

Atualização

Atualização (Update): Alterar os dados em uma tupla da relação.

Notações do modelo relacional

Notação tabular (tabelas)

Notação textual

Empregado (Mat, Nome, Função, Salário, Dep*)
Departamento (CodDep, Nome, MatrGerent*)

Generalização e Especialização

Generalização e Especialização são técnicas de modelagem que permitem representar um conjunto de entidades de forma mais abstrata. Ocorre herança de atributos entre as entidades, isto é, as entidades de nível inferior herdam todos os atributos e relacionamentos da entidade a qual estão ligadas.

SÍMBOLO: Um triângulo de "cabeça para baixo"

Especialização

Usada quando um conjunto de entidades possui subgrupos com características próprias.

Especificação de subgrupos dentro de um conjunto de entidades que são distintas, isto é, possuem casacterísticas específicas em um vez que possuem atributos ou relacionamentos que não se aplica ao conjunto entidade de nível superior.

Exemplo EMPREGADO pode ser HORISTA ou DIARÍSTA.

Generalização

Usada quando entidades distintas possuem características (atributos) em comum, possibilitando a criação de uma entidade mais genêrica que as represente.

Combina conjuntos de entidades, que compartilham as mesmas características (atributos/relacionamentos), em uma entidade de mais alto nível.

Redundância

A generalização/especialização é muito útil para evitar redundâncias, por exemplo:

Poderíamos refazer o modelo ER da seguinte forma:

Conselhos práticos

ATRIBUTO vs GENEREALIZAÇÃO/ESPECIALIZAÇÃO

Questão: modelar um determinado objeto, por exemplo, a categoria funcional de cada empregado de uma empresa.

Como atributo?

• Categoria funcional como atributo da entidade EMPREGADO.

Como generalização/especialização?

• Cada categoria funcional corresponderá a uma especialização da entidade EMPREGADO.

Atributo opcional

Pode indicar subconjuntos de entidades que são modelados mais corretamente através de especializações. Exemplo:

Tipos de generalização/especialização

Total

Nesse tipo generalização/especialização, a existência da ocorrência da entidade genérica OBRIGATORIAMENTE implica na existência da ocorrência da entidade especializada.

Parcial

Nesse tipo de generalização/especialização, a existência da ocorrência da entidade genérica NÃO OBRIGA a existência da ocorrência da entidade especializada.

Exclusiva

Em uma hierarquia de generalização/especialização, uma ocorrência da entidade genérica é especializada no máximo uma vez, nas folhas da árvore de generalização/especialização.

Compartilhada

Em uma hierarquia de generalização/especialização, uma ocorrência da entidade genérica aparecer em várias entidades especializadas, nas folhas da árvore de generalização/especialização.

União de tipos

Total + Exclusiva (tx)

Todo cliente DEVE ser ou pessoa física, ou pessoa jurídica, mas NÃO PODE ser ambos ao mesmo tempo.

Total + Compartilhada (tc)

Toda nacionalidade DEVE ser ou braileira, ou indiana, ou japonesa, ou mais de uma ao mesmo tempo.

Parcial + Exclusiva (px)

Todo Saiyajin PODE estar transformado OU NÂO, mas se estiver, so pode ter UMA transformação por vez.

Parcial + Compartilhada (pc)

Um médico PODE ser um cardiologista/neurologista OU NÃO, e se for, pode ser MAIS DE UM, ao mesmo tempo.

Níveis de especialização

Não existe um limite para o nível de especialização. A árvore de especialização pode ter mais de uma camada.

Herança múltipla

Uma herança múltipla ocorre quando uma entidade especializada é a especializada de mais de uma entidade genérica.

Entidade associativa

Suponhamos a seguinte situação: Considere o relacionamento abaixo, MÉDICO-consulta-PACIENTE, agora precisamos armazenar informações sobre medicamentos. Para isso vamos criar a entidade MEDICAMENTO.

Se associarmos a entidade MEDICAMENTO à entidade MÉDICO, só saberíamos qual médico receitou o medicamento, e não para qual paciente.

Se associarmos a entidade MEDICAMENTO à entidade PACIENTE, só saberíamos qual paciente recebeu a receita, e não quem receitou.

Queremos associar a entidade MEDICAMENTO à consulta. Porém, isso não está previsto no Modelo Entidade Relacionamento. Para isso foi criado o conceito de Entidade Associativa.

Esse conceito consiste em transformar um relacionamento em uma entidade para que dessa forma seja possível criar um relacionamento entre a entidade MEDICAMENTO e a entidade CONSULTA.

Sobre o Guia do Código Hacker

O Guia do Código Hacker foi inspirado no excelente Código Geek (Geek Code) de Robert Hayden, que é um dos favoritos dos hackers há muito tempo. No entanto, o Código Geek não é atualizado há muito tempo e, embora a comercialização da Internet tenha eliminado grande parte do antigo ambiente hacker (MUDs, BBSes, DOS...), devemos tentar manter vivas as tradições hackers, por reimplementação, se necessário.

Vamos ver um exemplo de um bloco de Código Geek:

-----BEGIN GEEK CODE BLOCK-----
Version: 3.12
GCS d- s+: a- C++ US++++ P++ L+++ E--- W++ N+ o K- w--
O+ M+ V PS++ PE- Y PGP+ t+ 5 X R tv+ b+ DI+ D+
G++ e++ h--- r+++ y+
------END GEEK CODE BLOCK------

O Código Geek faz muitas coisas bem:

• É MUITO geek. Strings de texto curtas com delimitadores + ou - para mostrar posições relativas em um problema.
• É único. É muito fácil identificar o código geek e ele vem sendo adotado por outros grupos que buscam formas de se identificar, mostrando sua versatilidade.
• É muito simples determinar por quais coisas uma pessoa é apaixonada. No exemplo acima, uma rápida olhada mostra que a pessoa parece ser um geek casado, liberal e amante do Unix, que não liga muito para programas de TV.

No entanto, também existem alguns problemas com o GeekCode:

• Em primeiro lugar, há muito espaço desperdiçado. Embora seja muito fácil determinar se uma pessoa é mestre em algo com 5 sinais de mais, é um desperdício. O local principal (e mais lógico) para exibir o código geek é no arquivo de assinatura. Ainda hoje, a netiqueta ainda favorece arquivos de assinatura curtos, e o Código Geek médio tem 6 linhas sozinho. Os geeks tendem a seguir a netiqueta quando possível, então isso faz com que as próprias pessoas visadas pelo Código Geek não o promovam em suas assinaturas!
• O código foi projetado para se parecer com um bloco de chave PGP, mas inclui caracteres que não são válidos em uma chave PGP, em particular, o símbolo de menos - e parênteses () são muito comumente usados. Os caracteres válidos em uma chave PGP são [A-Za-z0-9], mais + e barra /. Também não há espaços em uma chave normal.
• Não é enigmático o suficiente ;) Isso é uma brincadeira, mas é quase MUITO fácil determinar rapidamente o Código Geek de uma pessoa, o que meio que tira a diversão do tipo anel decodificador secreto das coisas.
• O problema mencionado acima é que o Código Geek está desatualizado.

O Guia do Código Hacker espera manter os aspectos bons do Código Geek e melhorar alguns dos ruins.
Os objetivos de design do Guia do Código Hacker são:

1. Uma chave normal com algumas opções de categoria extras deve caber em uma linha de texto de 80 colunas. Idealmente, ele deve ter espaço suficiente para que o URL da chave do hacker caiba na mesma linha, para dar às pessoas uma chance de descobrir o que diabos é.
2. Certifique-se de que os símbolos mais comumente usados também sejam símbolos de chave PGP válidos. Para compatibilidade com o Código Geek, usaremos mais símbolos que não são válidos, mas garantiremos que os mais usados sejam.
3. Mantenha o Guia atualizado. Só posso prometer que manterei o guia atualizado ou o entregarei a alguém que o faça. O tempo dirá se conseguirei cumprir essa promessa.

Formato de uma entrada de Código Hacker

Uma Código Hacker é construído da seguinte forma:

• A categoria em questão será listada em letras minúsculas (por exemplo, u é para Unix).
• O número correspondente à sua resposta à categoria (por exemplo, 7). Em vez de mais ou menos, é atribuída uma pontuação média de 5 para cada categoria. As respostas extremamente positivas são superiores a 5 (o máximo normal é 9), as respostas negativas são inferiores a 5 (o mínimo normal é 0).
• As opções opcionais de gaiola devem estar no final e em letras maiúsculas (por exemplo, SL para Solaris, Linux).
• Ao prosseguir para a próxima seção, não pule um espaço!

Então, para nosso exemplo, a categoria Unix seria preenchida como: u7SL

Modificadores (variáveis)

As "variáveis" do Geek Code mais comumente usadas parecem ser "intervalos" (@ e ()) e "aspirante" (>). Para seguir o Objetivo de Design nº 2, as seguintes alterações foram feitas na Chave Hackey:

• / - Para indicar uma resposta de "intervalo", use a tecla barra (/) em sua resposta. Para a opção (@) de variação livre, use um / no final da sua resposta numérica, por exemplo. u5/. Para indicar um intervalo específico em sua resposta, use a barra entre suas duas respostas, por exemplo. você5/7.
• + - Para indicar sua classificação de "aspirante", use o símbolo de mais (+). Sim, parece estranho e (>) é um caractere mais intuitivo, mas não usar um caractere-chave PGP válido quando é um dos dois únicos caracteres não alfanuméricos disponíveis seria uma farsa. Por exemplo, se você gosta de Unix, mas gostaria de ser um guru, você usaria u5+8.

O restante dos símbolos são compatíveis com o Código Geek. Eles estão listados para compatibilidade com o Código Geek, embora sejam opcionais e sejam caracteres inválidos em uma chave PGP. Para completar, aqui estão eles:

• $ - Para indicar que você ganha a vida com um certo tipo de hacking de atividade relacionada, adicione um $ no final, ex.: u9$
• ? - Afirma que não sabe nada sobre esta categoria. Se for esse o caso, por que você está criando um Código Hacker?
• ! - Recusa veemente em participar da categoria. Isso normalmente deveria ser feito com um 0 para uma categoria, então realmente não deveria ser usado. Para ser consistente com o Código Geek, se você decidir usar este caractere, coloque-o SOMENTE no início de uma categoria e obviamente não insira um valor numérico.

O guia em sí

v - Versão - Inclua a versão atual como a primeira entrada em sua chave de hacker.

A versão atual do Hacker Key é v4.

Parte I – Que tipo de hacker você é?

sw - Hacking de software (Software Hacking)

9 – Sou Bill Joy, Eric Raymond ou JWZ.
8 – Sou um uberhacker; Eu escrevi meu shell/depurador/editor/compilador em 30 linhas de código. Outras pessoas usam e amam meus hacks.
7 – Viva para Hackear, Hackeie para Viver!
6 – Não há nada melhor do que um hack elegante.
5 – Em média, fiz alguns hacks de software no meu dia.
4 – Já hackeei código uma ou duas vezes, software não é minha praia.
3 – Eu não hackeio software de jeito nenhum. Sou um programador estruturado!
2 – Não sou nem programador e muito menos hacker!
1 – Sou gerente e/ou trabalho na IBM.

Indique sua linguagem de hacking preferida

• C C(++)
• P Perl
• Y Python
• U Unix Shell
• B (Visual) Basic
• J Java
• A Ada
• S Assembler
• L Lisp
• G Prolog
• M Esquema
• F Fortran
• H PHP
• R Rubi

hw - Hacking de hardware (Hardware Hacking)

9 – Eu sou Steve Wozniak.
8 – Tenho meu próprio gravador de eeprom no porão. Eu não vou usar o que não foi feito por mim mesmo.
7 – Meus projetos de hardware foram usados em produtos reais.
6 – Já brinquei com alguns desenhos de hardware, mas nunca fiz meu próprio hardware. Conheço o hardware do PC como a palma da minha mão.
5 – Construí todos os PCs da minha casa do zero. Newegg me conhece por meu primeiro nome.
4 – Eu construí um ou dois PCs na minha época. É apenas mais fácil prepará–los.
3 – As pessoas me perguntam o que significa USB, eu sei algumas coisas sobre hardware.
2 – Sei montar meu computador sem diagrama.
1 – Cara! Você tem um Dell!

ln - Hacking de linguagem (Language Hacking)

9 – Eu sou J.R.R. Tolkien.
8 – Minha linguagem de estimação foi usada e estudada por outras pessoas.
7 – Pessoas que não me conhecem usaram palavras que criei. eu escrevi minha própria linguagem artificial.
6 – Sou conhecido por certas palavras ou frases, meus amigos usam minhas criações linguísticas regularmente.
5 – Criei uma frase ou inventei uma ou duas palavras novas.
4 – Sou um nazista gramatical; as pessoas odeiam falar comigo porque eu as corrijo no meio da frase.
3 – Odeio pessoas que não seguem as regras básicas do $LANG, que eu me esforcei para falar corretamente.
2 – Sou analfabeto e/ou só falo IM: l8r sk8r!
1 – Sou editor do Slashdot.

pr - Programação Ei, alguns hackers pensam que são programadores ;-)

9 – Só programo em ADA, e ADORO!
8 – Atualmente estou programando um link de conectividade célebro–IDE.
7 – Eu programo bastante, e passo muito tempo no meu IDE de escolha.
6 – Definitivamente sou um programador, não um hacker. Eu gosto do básio, um editor de texto e um compilador/depurador.
5 – Sou um programador comum, prefiro pensar que sou um hacker.
4 – Sacrificarei o design elegante pelo desempenho ou tamanho.
3 – Comentários são para maricas! Se foi difícil escrever, deveria ser difícil de ler.
2 – Posso escrever olá mundo, mas meus programas não fazem tanto assim.
1 – Não consigo programar de jeito nenhum.

Indique sua metodologia de programação

• O Orientado a Objetos
• S Estruturado
• A Orientado a Aspectos
• U Unificado
• R Racional Unificado
• P Processual
• F Funcional

ck - Cracking O ato malicioso de invadir sistemas que obtém todos os destaques; o que pessoas não técnicas consideram "hacking".

9 – Trabalho para @Stake ou escrevo por 2600.
8 – Eu escrevo os "sploits" que todas as crianças usam. eu seria um black–hat profissional, exceto para esta economia.
7 – Black Hat – Cracking é coisa antiga para mim. Eu só comprometo um sistema se parece um desafio. Script Kiddies me adoram.
6 – Gray Hat – Algumas dos meus cracks são para o bem, outras são para o mal. Isto realmente depende de quem se beneficia com o que eu faço.
5 – Tento invadir sistemas ocasionalmente. É para fins de educação, é isso!
4 – White Hat – Eu estudo exploits porque sou eu quem tem que corrigir os sistemas quando eles são liberados. Eu assino o CERT.
3 – Já tentei uma ou duas vezes, mas achei errado. Eu fico com o warez.
2 – Nunca tento invadir um computador, isso é contra a lei!
1 – Mal sei quebrar um ovo!

ma - Matemática A matemática ocupa grande parte da computação, e portanto, o hacking. Indique o seu mais alto grau de Matématica.

9 – Cálculo/Teoria Avançada
8 – Equações Diferenciais
7 – Cálculo II
6 – Probabilidade/Estatísticas
5 – Álgebra Linear
4 – Cálculo I
3 – Terminei o HS Math e percebi que isso era o suficiente para mim
2 – Ainda no ensino médio e indo muito bem.
1 – Fico irritado com os números. Há muitos deles e outras coisas.

Parte II – Guerra de S.O.!

u - Unix

9 – Eu sou Ken Thompson.
8 – Eu sou um guru. Todo mundo me pede ajuda com suas máquinas Unix. Unix é mais que um sistema operacional, é minha religião!
7 – Utilizo exclusivamente Unix em todos os meus computadores. Se não é Unix, é uma merda!
6 – Gosto muito de Unix; Eu instalei o Linux uma ou duas vezes, mas principalmente uso Windows ou MacOS para minhas necessidades diárias.
5 – Unix está bem, é apenas uma ferramenta como qualquer outra.
4 – O Mac OS X é o mais próximo do Unix que eu gostaria de chegar.
3 – Não gosto de Unix, é muito enigmático, e que porcaria de shell é essa! A GUI é muito superior!
2 – Unix é uma abominação. É um daqueles sistemas operacionais mortos que não percebe ainda que está morto.
1 – Eu sou Bill Gates.

Insira seus sistemas operacionais *nix mais (menos) favoritos:

• L Linux
• I Irix
• A AIX
• S (Open) Solaris
• F FreeBSD
• N NetBSD
• O OpenBSD
• B Outro BSD
• H HP-UX
• M MacOS X
• T Tru64

w - Windows

9 – Eu trabalho para a Microsoft, eles me chamam de code monkey... bem, apenas monkey.
8 – Eu instalo todas as versões beta da versão mais recente do Windows que consigo sair da rede. Eu quero trabalhar na Microsoft.
7 – Desenvolvi meus próprios programas para Windows, VB e .NET me pertencem.
6 – Gosto muito do Windows; Eu tenho meu tema de área de trabalho e protetor de tela do jeitinho que eu gosto.
5 – O Windows está OK, estou bastante indiferente a isso.
4 – Quando é que vão parar de roubar ideias alheias e surgir com algo INOVADOR? Eu ainda o executo, o que mais há?
3 – Eu mantenho o Windows no meu disco rígido apenas para testar o novo hardware que compro. Regras do Linux!
2 – Aniquilei totalmente o Windows do meu disco sem olhar para trás!
1 – Na verdade, nunca usei o Windows, estou completamente imaculado!

• D MS-DOS/Windows 3.x
• N Windows NT
• T Windows 2000
• W Windows 95/98/Me
• C Windows CE/Mobile
• X Windows XP
• U Windows Server 2003
• V Vista

Modificadores especiais

• G Utilizo máquinas Windows mas apenas com Cygwin instalado

m - MacOS (X) Vamos ser sinceros, minhas crianças, o OS 9 está morto.

9 – Eu sou Steve Jobs.
8 – Já escrevi livros sobre programação com Cocoa e Carbon. Vejo você na WWDC!
7 – Adoro! O poder do Unix e uma GUI aqua elegante são o auge da computação. Eu escrevi um ou dois aplicativos ocasionais.
6 – Gosto do novo MacOS. Finalmente estabilidade E facilidade de uso!
5 – MacOS X está bem. Um bom front-end GUI para um sistema operacional Unix.
4 – Não gosto disso. Não há ênfase suficiente na CLI.
3 – Eu odeio isso. A GUI ocupa metade da minha RAM e ainda trava pra mim, mesmo sendo baseada em UNIX!
2 – Desprezo o MacOS X. Sinto falta do MacOS "Clássico" (<= 9).
1 – Desprezo o MacOS X. Sinto falta do Apple II.

l - Linux O sistema operacional gratuito que mudou a computação. Para a turma do GNU/Software Livre, use g/l (GNU/Linux).

9 – Sou Linus Torvalds ou Alan Cox.
8 – Sou um hacker/mantenedor de pacotes ativos do kernel. Se o Linux não existir, talvez eu tenha que sair de casa de vez em quando!
7 – Sou um usuário avançado. Desenvolvi minha própria minidistribuição por capricho. Perdi a conta de quantos kernels compilei.
6 – Gosto muito de Linux. Eu tentei algumas distribuições e estou quase decidindo por uma. Windows sucks.
5 – Linux é ok.
4 – Não gosto de Linux. Ainda depende muito da linha de comando.
3 – Eu odeio Linux. Não é realmente UNIX, é uma cópia barata. Essa coisa toda de feridas abertas nunca vai funcionar!
2 – Eu desprezo o Linux e seus apoiadores comunistas. Graças a Deus há um uma grande empresa como a Microsoft e um ótimo sistema operacional como o Windows!
1 – Trabalho para a SCO

Inclua sua distribuição favorita. Como qualquer bom fanático sabe, só pode haver um!

• A Damn Small
• D Debian
• E (Open) SuSE
• F Fedora Core
• G Gentoo
• I (Lin|Free) spire
• K Knoppix (et al)
• L Linux From Scratch
• M Mandriva
• P Puppy
• R Red Hat
• S Slackware
• U Ubuntu (et al)
• V Vetor

O – outra distro de sua escolha! Existem mais distros do que letras, e eles vêm, vão e se fundem mais rápido do que posso atualizar. Então, aqui está a sintaxe para adicionar seu favorito:
Adicione o nome da sua distribuição imediatamente após o O e acrescente um caractere de barra (/), exemplo:
lOgNewSense/ para os entusiastas do combo FSF-and-Ubuntu. O modificador O deve ser o ÚLTIMO listado para esta categoria para minimizar confusão.

i - IDE/Editor de texto

Como todos parecem ter seu próprio editor de texto favorito, os números mostrarão seu interesse em IDE/integração, bem como seu ambiente favorito.

0 – cat
1 – ed
2 – vi (e seus clones)
3 – jed
4 – jove
5 – pico/nano
6 – emacs
7 – CodeWarrior
8 – Visual Studio
9 – Xcode
A – Anjuta
C – Eclipse
D – Delphi
E – ee
F – (v)FTE
G – GNUstep
H – HTE
I – NEdit
J – jEdit
L – Idle
N – Notepad doente
P – Powerbuilder
T – Textpad
O – outro IDE de sua escolha! Sim, quase ficamos sem cartas para IDEs, então aqui está a sintaxe para adicionar seu editor ou IDE favorito:
Adicione seu programa imediatamente após o O e acrescente um caractere de barra (/), por exemplo: iOBBEdit/ para os fãs do BBEdit por aí, ou iOdd/ para aqueles verdadeiros durões do Unix (não). O modificador O deve ser o ÚLTIMO listado para esta categoria para minimizar confusão.

Parte III – Vida e Estilo de Vida - seção "work friendly"

e - Educação Indique o seu nível de escolaridade mais alto.

9 – Sou onisciente, seu idiota insensível!
8 – Doutorado
7 – Mestrado
6 – Bacharelado
5 – Escola Comercial/Técnica/Associados
4 – Alguma faculdade
3 – Diploma de ensino médio
2 – Atualmente cursando o ensino médio
1 – Ensino fundamental/médio
0 – Não precisamos de educação

t - Televisão A maioria dos hackers não assiste muita TV (é hora de eles estarem hackeando!), mas para completar, ela está incluída.

9 – Sou Max Headroom.
8 – Faz tempo que desisti de outras coisas como trabalhar, conversar com outras pessoas e sair de casa. Tenho soro intravenoso e diálise, então não preciso me preocupar com funções corporais incômodas.
7 – Assisto TV religiosamente. A televisão nunca está desligada na minha casa. Tenho um gerador para poder assistir TV mesmo quando há queda de energia!
6 – Assisto muita TV. Eu tenho um TiVo só para poder assistir todos os programas das minhas séries favoritas!
5 – Assisto TV algumas horas por dia e tenho alguns programas favoritos.
4 – Assisto TV de vez em quando. Simplesmente não há mais muita coisa boa.
3 – TV é um lixo. Prefiro ler um livro ou dar um passeio.
2 – A TV é apenas a ferramenta de controle do (Diabo | Governo | Grandes Empresas)! Jogue fora sua TV!
1 – Eu sou Amish

Série de TV Hackers:

• T Star Trek
• N TNG
• D DS9
• V Voyager
• E Enterprise
• B Babylon 5
• S Stargate SG1/Atlantis
• H Xena/Hércules
• L LEXXX
• F Farscape
• R Red Dwarf
• X The X Files
• M Monty Python
• A Adult Swim
• G Battlestar Galactica
• W Doctor Who

b - Livros (Books) _Muita variedade aqui, já que alguns hackers são ávidos leitores, enquanto outros se limitam à web.

9 – Sou obcecado por leitura. Na verdade, escrevo meus próprios contos/poesias, além de ler livros.
8 – Sou uma espécie de leitor ávido, procuro ler um livro por semana/mês.
7 – Leio livros reais, não apenas referências técnicas.
6 – Pego o livro ímpar. Conheço bem as fronteiras locais.
5 – Leio livros ocasionalmente. Você quer dizer além dos livros da O'Reilly? Ah, então não.
4 – Não leio livros, a web é um meio de leitura suficiente para mim.
3 – Não leio um livro desde a faculdade.
2 – Não leio um livro desde o ensino médio.
1 – Sou analfabeto (Ver ln1).

Livros e autores favoritos dos hackers:

• A Isaac Asimov
• D O Novo Dicionário do Hacker
• G William Gibson
• H Guia do Mochileiro
• I Trilogia Illuminatus
• L C. S. Lewis
• K Philip K. Dick
• M Páginas de Manual/Texto informativo
• O Livros técnicos O'rielly
• P Série Harry Potter
• R Request for Comments (RFCs)
• S Neil Stephenson
• T J.R.R. Tolkien

en - Criptografia O único obstáculo real entre seus dados e um cracker, ou não?

9 – Tenho meu próprio algoritmo de criptografia com meu nome.
8 – Posso decifrar a Enigma na minha cabeça.
7 – Eu uso GnuPG para todos os emails e tenho muitos sistemas de arquivos criptográficos no meu disco rígido. Se você quiser meus dados, terá que conquistá-los!
6 – Utilizo criptografia com frequência. Quer assinar minha chave?
5 – Gosto e uso criptografia.
4 – Não uso criptografia. Não tenho nada a esconder.
3 – A criptografia é uma sobrecarga desnecessária. Se você usá-lo, deve ter algo a esconder!
2 – Somente terroristas usam criptografia. O governo deveria ter back doors para todos os mecanismos de criptografia.
1 – Somente o governo deveria poder usar criptografia para poder manter seus segredos seguros!

g - Jogos Seja console ou PC, os videogames são populares entre alguns hackers.

9 – Eu sou John Carmack.
8 – Desenvolvi o jogo ocasional. As pessoas me consideram um guru dos jogos. As pessoas se desconectam dos servidores quando me veem fazer logon.
7 – Brinco o tempo todo, quando não estou hackeando, comendo ou dormindo.
6 – Jogo com frequência, tenho um ou dois consoles e/ou alguns jogos para PC.
5 – Vou pegar um jogo ocasional.
4 – Eu costumava jogar videogame na época dos 8 bits, mas não mais.
3 – Não gosto de videogame, nessa hora eu poderia estar hackeando.
2 – Não gosto de videogame, nessa hora eu poderia estar dormindo.
1 – Sou péssimo em videogame.

Gênero:

• R RPG Gráfico
• A Ação/Aventura
• S Esportes
• Z Puzzle
• T Baseado em texto/MUD
• O Tiro
• V Jogos multijogador massivo (como você encontra tempo para hackear??)
• G Estratégia em tempo real

Console:

• C Sistemas "clássicos" (ou seja, mortos) - Nintendo [S]NES, Sega
• M Sistemas modernos (PS2/3, XBOX (360), GameCube/Wii).
• H Portáteis (Gameboy/PSP)
• P PC Gamer

Parte IV – Vida e Estilo de Vida - seção "work unfriendly"

Sim, pessoas que trabalham em megacorporações malignas foram punidas por terem essas seções em seus Códigos Hacker, então moveremos esta seção para o final. Observe que TODAS as seções são OPCIONAIS, mas esta em particular você pode querer deixar de fora.

a - Idade

[0-9][0-9] – Idade real
[0-9]X – Só tenho vontade de atualizar minha idade uma vez por década!
F – 100+ (Velho Peido)
Eu – Imortal
N – N/A ou Não é da sua conta

s - Sexo Se não tivéssemos, de onde viriam os bebês?

9 – Meu nome é Jenna Jameson.
8 – Sou um (a) ninfomaníaco (a). Se não faço sexo a cada 6 horas fico totalmente irritado.
7 – Já fiz mais do que a minha cota de sexo. Eu sou um garanhão!
6 – Já fiz sexo mais do que algumas vezes. Ainda estamos no cenário do namoro, então não vamos entrar em números.
5 – Já fiz sexo. Próximo assunto.
4 – Não fiz sexo, não que não tenha tido oportunidade mas estou me salvando.
3 – Ainda nem passei da segunda base. Assim que meu rosto melhorar, vou pegar alguns!
2 – Sexo é sujo! Guarde para alguém que você ama!
1 – Sou membro do clero. Nada para mim, obrigado.

0 – Sou um eunuco.
$ – Sou uma prostituta.

• M Masculino
• G Gay/Lésbica
• S Solteiro
• T Travesti
• F Feminino
• B Bissexual
• R Casada
• D BDSM
• W Swinger
• I Envolvido (namoro)

r - Religião Geralmente os hackers acreditam em alguma coisa, mesmo que seja apenas em seu sistema operacional favorito. Outros têm uma opinião real sobre um Poder Superior

9 – Eu sou Deus, seu tolo mortal!
8 – Panteísta – O Universo É Deus.
7 – Pagão/Wiccano – Eu adoro mais a natureza do que uma divindade.
6 – Politeísta – Acredito em múltiplos Deuses.
5 – Monothiest – Só existe um Deus.
4 – Teísta – Deus existe e interage com o mundo e com Seus seguidores.
3 – Deísta – Deus existe, mas não intervém no mundo.
2 – Agnóstico – Inseguro da existência de Deus.
1 – Ateu – Deus não existe.

p - Política

Para a versão 4, use as classificações do Political Compass (www.politicalcompass.org). Basta listar seu nível econômico "Esquerda/Direita" e o nível social "Libertário/Autoritário" com uma barra entre elas, ou arredonde para cima/para baixo para o número inteiro mais próximo para economizar espaço (preferencial). Sim, o símbolo (-) não é PGP válido, mas pelo menos a categoria agora é um tanto útil.

Se você listar apenas um número nesta categoria, será consideradoa a classificação Social Libertário/Autoritário, já que as questões sociais tendem a ser mais importantes para os hackers.

Exemplo (ambas as categorias): p-4,20/-5,10 ou (preferencialmente) p-4/-5
Exemplo (somente social): p6.10 ou (preferencialmente) p6

Exibindo seu Código Hacker

Devido ao seu design, o Código Hacker deve caber discretamente em seu arquivo de assinatura. Como o Guia do Código Hacker não é muito conhecido, se você puder incluir uma referência ao site, isso ajudará a divulgar o Guia. Aqui está um exemplo da versão 4 do Código Hacker:

v4sw5Uhw6ln5pr7FOck5ma4u7Lw3Vm5l6OManjaro/i2OVscode/e6t5b7ATen6g5RASOCMPaNr2p1/-9 hackerkey.com

Quem é responsável pelo Código Hacker?

O crédito deve ficar com você, Chris Allegretta <chrisa@asty.org>. Inspiração adicional, sugestões e feedback foram dados por Murray Schwalbaum, <loser@e0f.org>. Obrigado também a Charles Mason, Jim Ault, Eric Tucker e Jason Burks pelas sugestões para a versão 0.

Para a versão 2, gostaria de agradecer: Daniel Keep, Luke-Jr, Tony Lainson e Cody Hatch pela revisão da seção Política.

Para a versão 3, gostaria de agradecer a Jon Spriggs, Stephen E. Mynhier, Kyle Goetz, Neil Williams, Roie Marianer, Eric Davis e Joey Harrison pelas sugestões de categoria ou organização.

Para a versão 4, gostaria de agradecer a Scott A Gallaher (w), Thomas Jollans (ma e e), Jon Wickes (g), Matej Cizek e Fabio Emilio Costa (b), Sandy Knight por O em (l) e (i), e especialmente a Carlos Alberto Pinto Peixoto Bastos Santos pelas diversas sugestões para (l) e por me indicar o site do Political Compass para (p).

Feedback - Por favor!

O Guia ainda é bem jovem e estou muito interessado em ouvir a opinião de vocês sobre o que você gosta, o que não gosta e acha que o Guia precisa ou não. Por favor, não sugira mudanças radicais na própria estrutura do código, pois esta é a única área com a qual me sinto bastante confortável. Envie suas idéias para chrisa@asty.org.

Licença

Direitos autorais (c) 2003-2006 Chris Allegretta
É concedida permissão para copiar, distribuir e/ou modificar este documento sob os termos da GNU Free Documentation License, Versão 1.2 ou qualquer versão posterior publicada pela Free Software Foundation; sem seções invariantes, sem textos de capa e sem textos de contracapa. Uma cópia da licença está incluída na seção intitulada "GNU Free Documentation License".

Histórico

• v0 - Lançado em 29.11.2003 - lançamento RFC
• v1 - Lançado em 08.02.2004 - Adicionadas seções de Programação e Matemática, adicionada categoria Swinger a Sexo, categorias de jogos renovadas
• v2 - Lançado em 17.04.2005 - Divida a seção III em 'amigável ao trabalho' e 'hostil ao trabalho'. Reescreveu a categoria política por ser muito centrada na política dos EUA.
• v3 - Lançado em 22.02.2006 - Adicionado: PHP e Ruby para sw, Dr Who e Battlestar Galactica para t, Idle e Anjuta para i, Envolvido para s, Windows Server 2003 e Vista para w. Alterado: duplicar S para atiradores para O em g.
• v4 - Lançado em 29.12.2006 - Adicionado: Cygwin para w, MMO e RTS para g, muitas novas entradas para b. Alterado: m e e retrabalhados para os hackers ainda na escola secundária, l completamente renovado (várias letras de distro alteradas e adicionadas) e adicionadas (O) outras categorias especificadas pelo usuário a l e i, descartadas categorias p em favor das classificações do site Polical Compass.

Introdução

MER - Modelo Entidade-Relacionamento

Baseia-se na percepção de um universo constituído por um grupo básico de objetos chamados entidades e por relacionamentos entre estes objetos.
- Peter Chen, 1976

O MER é um modelo de dados conceitual de alto-nível, ou seja, seus conceitos foram projetados para serem compreensíveis a usuários, descartando detalhes de como os dados são armazenados.

Vantagens

• Simplicidade
• Independe do SGDB a ser utilizado
• Mundo real a ser mapeado (mini-mundo) pode ser visto como um conjunto de entidades e de relacionamentos entre as mesmas.
• Desenvolvido para facilitar o projeto de banco de dados
• Especifica "quais" os dados serão representados (O QUE) e não "como" os dados serão armazenados.
• Elementos do modelo:
  • Entidades
  • Relacionamentos
  • Atributos

Entidade

Qualquer objeto, pessoa, lugar, conceito ou "coisa" no mundo real com uma existência própria/independente e sobre a qual seja necessário armazenar informações ou características.

Pode ter uma existência física (um rio, uma estrada, uma casa, um aluno, um carro, um cantor...) ou uma existência conceitual (um cargo, um curso, um evento..).

SÍMBOLO: Utiliza-se um retângulo para representar uma entidade, geralmente o nome é escrito no singular.

Entidade Fraca

Caracterizada pela sua dependência da existência de outra entidade.
Uma entidade fraca não possui características o suficiente para existir "sozinha".

SÍMBOLO: Utilizamos um retângulo inscrito em outro retângulo para representarmos uma entidade fraca

Relacionamento

Um relacionamento descreve um associação entre suas ou mais entidades (ação)

SÍMBOLO: Utilizamos um lozango para representarmos um relacionamento

Relacionamento dependente

O relacionamento dependente é usado quando queremos relacionar uma ENTIDADE com uma ENTIDADE FRACA.

SÍMBOLO: Utilizamos um losango inscrito a outro losango para representar um relacionamento dependente

Atributo

O atributo é cada característica, propriedade ou qualidade específica que descreve e/ou relacionamento.

Isto é...

• A entidade EMPREGADO poderia ter os atributos: nome, endereço, data de nascimento, salário e profissão.
• A entidade EMPRESA poderia ter os atributos: nome, razão social, CNPJ, matriz, presidente, endereço, telefone.
• A entidade CARRO poderia ter os atributos: fabricante, modelo, ano de fabricação, cor, número de portas, placa, chassi.

SÍMBOLO: Utilizamos uma elípse (círculo ovulado) para representarmos um atributo.

Representação gráfica dos atributos da entidade CLIENTE:

ATRIBUTO CHAVE ou CHAVE

São atributos ou conjunto de atributos que identifica unicamente e exclusivamente uma entidade, ou seja, não há valores repetidos desse atributo na entidade. Sendo assim, o seu valor pode ser usado para identificar cada entidade.

Alguns tipode de entidades podem ter mais que um atributo-chave, exêmplo: CPF, identidade, matrícula, CIU.

O atributo chave deve aparecer sublinhado em sua simbologia.

ATRIBUTO CHAVE PARCIAL ou CHAVE PARCICAL

TL;DR: chamamos de chave-parcial o atributo chave de uma entidade-fraca

Uma entidade-fraca tem uma chave-parcial, que é um atributo (ou conjunto de atributos) que podem univocadamente identificar entidades-fracas relacionadas à uma entidade (forte).

Um tipo de entidade-fraca pode, algumas vezes, ser representado como atributo composto (endereço).

A escolha de qual representação usar é determinada pelo projetista do banco de dados.

Atributo simple ou atômico

São atributos que não são divisíveis, representam uma informação exata e direta, e que não são possíveis de serem decompostos em mais atributos.

Atributo composto

É um atribusto que pode ser composto de outros atributos mais básicos.

Atributo multivalorado

São atributos que possuem um ou mais valores de um mesmo tipo

SÍMBOLO: Um círculo ovalado dentro de outro círculo ovalado

Exemplo 2
Um atributo idioma de uma entidade ALUNO pode conter os valores inglês e francês. Para um outro aluno poderia conter apenas um valor, como espanhol. Para um terceiro aluno, poderíamos ter 3 valores para esse atributo: inglês, francês e espanhol.

Atributo derivado

Este tipo de atributo é derivado de outros atributos.

Não necessitam serem armazenados na base de dados, podendo ser calculados apartir de um consulta através da aplicação.

O atributo idade de uma PESSOA. Para uma pessoa em particular, podemos determinar o valor atual de idade através do atributo data_nascimento e da data atual do sistema operacional.

Então a idade é chamada atributo derivado, pois pode ser obtida de outros atributos.

SÍMBOLO: Círculo ovalado com contorno pontilhado.

Boas práticas: Sujestão para nomes

A literatura não define um padrão, mas algumas práticas são usadas:

Entidades

• Nomes breves e objetivos, com letras maiúsculas que identifique facilmente o conteúdo da entidade;
• No singular, já que a pluralidade decorre, naturalmente, do número de ocorrências, característica própria de toda entidade;
• Nomes compostos separados por hífen -, eliminando-se o uso de preposições ou outros termos de ligação.

Relacionamentos

• Palavras escritas com letras minúsculas;
• Palavras compostas use underline _.

Atributos

• Primeira letra do nome maiúscula e o restante mínúscula;
• Palavras compostas use underline _;
• Palavras repetidas em outras entidades, use a inicial da entidade no início e continue com o nome. Ex.: Empr_Nome para o nome da EMPRESA, Dept_Nome para o nome do DEPARTAMENTO.

Praticando

Controle de professores FAPAM

A FAPAM precisa ter controle de seus professores e quais turmas eles estão lecionando. Para isso ela precisa saber do professor o nome, CPF e o salário. Já de suas turmas, a faculdade precisa saber a descrição, quantos alunos possui e a carga horária.

Instituição de Ensino

Fomos contratados por uma instituição, e a mesma, precisa ter um sistema para controle de cursos, sabemos que precisamos ter informações dos alunos, dos cursos e de professores. De cada aluno, será necessário armazenar: seu nome, matrícula, data de nascimento e idade. De cada curso será necessário armazenar a descrição e quantidade de alunos inscritos. Do professor, o seu nome e CPF.

Tipos de relacionamento

Os tipos de relacionamento estão associados ao conceito denominado cardinalidade.

A cardinalidade é a quantidade de ocorrências que uma entidade pode ter em relação a outra entidade.

Cardinalidade nos RELACIONAMENTOS:

• Relacionamento 1:1 Lê se UM PARA UM
• Relacionamento 1:N Lê se UM PARA MUITOS
• Relacionamento N:M ou N:N Lê se MUITOS PARA MUITOS

Relacionamento 1:1

Um relacionamento 1:1 é um relacionamento onde UMA entidade está associada a UMA outra entidade, e vice-versa.

Relacionamento 1:N

Um relacionamento 1:N é um relacionamento onde UMA entidade está associada a MUITAS outras entidades, mas as entidades associadas estão associadas a apenas UMA entidade.

Relacionamento N:M

Um relacionamento N:M é um ripelacionamento onde MUITAS entidades estão associadas a MUITAS outras entidades.

Par de cardinalidades

Alguns livros trazem a notação de par de cardinalidade, que de define através da atribuição de um valor mínimo e um valor máximo para os tipos de relacionamentos existentes.

Um empregado obrigatóriamente está lotado no máximo em 1 departamento. Um departamento pode ter até N empregados lotados nele.

Atributos em relacionamentos

Os relacionamentos também podem ter atributos. Por exemplo: pode haver a necessidade de representar a quantidade de horas semanais trabalhadas pode um empregado em um dado projeto. Isto pode ser representado no relacionamento trabalha_em na forma do atributo denominado Horas

Praticando

Projetos de uma empresa

Numa empresa os funcionários são descritos por um nome, número do CPF, salário, endereço (logradouro, número, bairro, cidade), data de nascimento e sexo. Tanto o número do CPF possui valor exclusivo para cada funcionário.

Os funcionários pertencem a departamentos da empresa. Cada departamento possui um nome, um número, uma localização e uma sigla que o identifica. Esta sigla é exclusiva de cada departamento.

Cada departamento é supervisionado por um funcionário da empresa. É necessário saber a data de início da supervisão, para que a cada dois anos haja substituições.

Os departamentos possuem projetos associados. Cada projeto é identificado por um nome, um código e um número de funcionários alocados. O código do projeto é exclusivo para cada um deles.

Os funcionários da empresa trabalham em projetos, e o número de horas dedicadas a um determinado projeto deve ser armazenado no BD.

Cia de seguros de automóveis

Uma cia de seguros de automóveis possui vários cliente (nome, endereço, CPF, e telefone(s)), cada um deles são proprietários de um ou mais veículos (fabricante, modelo, ano, placa, estado).

Cada carro está associado a nenhum ou vários registros de acidentes (data, número do BO). Um acidente pode evolver não apenas um, mas vários carros.

Multi Relacionamentos

Um relacionamento liga duas entidades, porém, é possível que uma entidade se relacione com outra entidade mais de uma vez.

Auto relacionamento

O auto relacionamento, também chamado de relacionamento recursivo, ocorre quando uma entidade se relaciona consigo mesma.

Auto relacionamento (1:N)

O relacionamento supervisiona relaciona um empregado com o seu supervisor, onde ambas entidades são membros do mesmo tipo de entidade EMPREGADO. Assim, o tipo de entidade EMPREGADO participa duas vezes: uma vez no papel de supervisor e outra no papel de supervisionado. Assim, e1 supervisiona e2, e2 supervisiona e3 e e1 supervisiona e4.

Auto relacionamento (N:N) e (1:1)

Cada disciplina pode ter um ou mais pré-requisitos (disciplinas), e cada disciplina pode ser pré-requisito de uma ou mais disciplinas.

Cada pessoa casa com uma pessoa, e cada pessoa é casada com uma pessoa. na maioria dos casos

Introdução

De início estamos usando o Portugol Visualg, você pode baixar a versão 3.06 aqui, apenas para Windows.

Todos os códigos também vão estar em um repositório espelho no Github: https://github.com/mateusfg7/atividades-programacao-estruturada-fapam

Pra quem usa VSCode, pode instalar a extensão Design Líquido - Linguagens em Português para ter syntax hightlight em linguagens em português e outros dialetos de Portugol (Portugol Studio, Postugol VisuAlg, BRIL, êtc.).

Dicas Visualg

Atalhos

Aula 2 - VisuAlg

Data: 15/02/2024

Exercício 1

Escreva um algoritmo que leia as três notas do aluno, calcule e imprima no console a média que ele obteve na disciplina.

algoritmo "MediaNotas"
// Disciplina  : Programação Estruturada
// Professor   : Adjenor Cristiano Queiroz
// Descrição   : Algoritmo que lê as três notas do aluno,
//               calcula e imprima no console a média que
//               ele obteve na disciplina.
// Autor(a)    : Mateus Felipe Gonçalves <contato@mateusf.com>
// Data atual  : 16/02/2024

var
   primeira_nota: inteiro
   segunda_nota:  inteiro
   terceira_nota: inteiro
   media: real
   loop:  caractere

inicio
   loop <- "sim"

   enquanto (loop = "sim") faca
      limpatela()
      escreval("-----| NOTAS |-----")
      escreval("")

      escreva("Primeira Nota --- ")
      leia(primeira_nota)
      escreva("Segunda Nota ---- ")
      leia(segunda_nota)
      escreva("Terceira Nota --- ")
      leia(terceira_nota)

      escreval("")

      media <- (primeira_nota+segunda_nota+terceira_nota)/3
      escreval("MÉDIA:", media)

      escreval("")
      escreval("-------------------")
      escreval("")
      escreval("Nova consulta? [sim|nao]")
      escreva("-> ")
      leia(loop)
   fimenquanto

fimalgoritmo

Exercício 2

Sabe-se que o m² de construção custa R$850. Escreva um algoritmo que leia as medidas de um terreno retangular e calcule e imprima quanto custa para construir uma casa que ocupe todo esse terreno.

Algoritmo "ValorM²"
// Disciplina  : Programação Estruturada
// Professor   : Adjenor Cristiano Queiroz
// Descrição   : Algoritmo que lê as medidas de um
//               terreno retangular e calcule e imprime quanto
//               custa para construir uma casa que ocupe todo
//               esse terreno.
// Autor(a)    : Mateus Felipe Gonçalves <contato@mateusf.com>
// Data atual  : 16/02/2024
Var

   VALOR_METRO_QUADRADO: real
   escolher_valor:       caractere

   altura_terreno:       real
   largura_terreno:      real

Inicio
   VALOR_METRO_QUADRADO <- 850

   escreval("-| FORMULARIO |-------------------------")
   escreval("")

   escreval("Largura do terreno (m)")
   escreva("-> ")
   leia(largura_terreno)

   escreval("")

   escreval("Altura do terreno (m)")
   escreva("-> ")
   leia(altura_terreno)

   escreval("")

   escreval("Escolher valor do m²? (Padrão: R$850.00)")
   escreva("[sim|nao] -> ")
   leia(escolher_valor)

   escreval("")

   se escolher_valor = "sim" entao
      escreval("Valor do m² (Ex.: 900.00)")
      escreva("-> ")
      leia(VALOR_METRO_QUADRADO)

      escreval("")
   fimse

   escreval("-| RESULTADOS |-------------------------")
   escreval("")

   escreval("Tamanho do terreno  =", altura_terreno*largura_terreno, "m²")
   escreval("Custo de construção = R$", (altura_terreno*largura_terreno)*VALOR_METRO_QUADRADO)

   escreval("")
   escreval("----------------------------------------")
Fimalgoritmo

Exercício 3

Escreva um algoritmo que leia o salário total de uma pessoa e quantas horas ela trabalha por dia, em seguida, calcule e imprima quanto essa pessoa recebe por hora. Considere o mês com 30 dias.

Algoritmo "CalcularSalario"
// Disciplina  : Programação Estruturada
// Professor   : Adjenor Cristiano Queiroz
// Descrição   : Algoritmo que lê o salário total de
//               uma pessoa e quantas horas ela trabalha por dia,
//               e calcula e imprime quanto essa pessoa
//               recebe por hora.
// Autor(a)    : Mateus Felipe Gonçalves <contato@mateusf.com>
// Data atual  : 16/02/2024
Var
   DIAS_NO_MES: inteiro
   dias_uteis:  inteiro

   salario:       real
   horas_por_dia: inteiro

   horas_por_mes:    inteiro
   salario_por_hora: real

Inicio
   DIAS_NO_MES <- 30

   escreval("-| CALCULAR SALÁRIO |------")
   escreval("")

   escreval("Seu salário (Ex.: 1400.00)")
   escreva("-> ")
   leia(salario)

   escreval("")

   escreval("Horas de trabalho (Ex.: 8)")
   escreva("-> ")
   leia(horas_por_dia)

   escreval("")

   // 4 semanas no mês, sábado e domingo não conta, ou seja:
   // 4*2 = 8 dias não úteis
   dias_uteis <- DIAS_NO_MES - 8
   horas_por_mes <-  dias_uteis * horas_por_dia

   salario_por_hora <- salario/horas_por_mes

   escreva("Seu valor /hora = R$", salario_por_hora)

   escreval("")
Fimalgoritmo

Exercício 4

Escreva um algoritmo que peça ao usuário para informar o peso e a altura com o comando leia, depois calcule e imprima na tela o IMC dessa pessoa sabendo que a fórmula do IMC é (peso/altura²).

Algoritmo "CalculaIMC"
// Disciplina  : Programação Estruturada
// Professor   : Adjenor Cristiano Queiroz
// Descrição   : Calcula IMC de uma pessoa
// Autor(a)    : Mateus Felipe Gonçalves <contato@mateusf.com>
// Data atual  : 16/02/2024
Var
   preso_em_km:  real
   altura_em_cm: inteiro

   IMC: inteiro

Inicio
   escreval("# CALCULADORA IMC ########")
   escreval("")

   escreval("Seu peso /Kg (Ex.: 59.9)")
   escreva("-> ")
   leia(preso_em_km)

   escreval("")

   escreval("Altura /cm (Ex.: 170)")
   escreva("-> ")
   leia(altura_em_cm)

   escreval("")

   escreval("# RESULTADOS #############")
   escreval("")

   escreval("Seu IMC =", preso_em_km/((altura_em_cm/100)^2))

   escreval("")
   escreval("##########################")
Fimalgoritmo

Aula 3 - VisuAlg

Data: 22/02/2024

Exercício 1

Desenvolva um software que receba uma idade do usuário e imprima na tela se ele é maior de idade ou menor de idade.

Algoritmo "Idade"
// Disciplina  : Programação Estruturada
// Professor   : Adjenor Cristiano
// Descrição   : Determina se o usuário é maior de idade ou não
// Autor(a)    : Mateus Felipe Gonçalves <contato@mateusf.com>
// Data atual  : 23/02/2024
Var
   idade: inteiro

Inicio
   escreval("Sua idade")
   escreva("-> ")
   leia(idade)

   escreval("")

   se (idade >= 18) entao
      escreva("Maior de idade")
   senao
      escreva("Menor de idade")
   fimse

   escreval("")
Fimalgoritmo

Exercício 2

Desenvolva um software que receba um nome e o sexo do usuário, após imprima na tela uma saudação conforme o sexo do usuário, EX: “Bem Vindo José” ou “Bem Vinda Maria”.

Algoritmo "Saudação"
// Disciplina: Programação Estruturada
// Professor:  Adjenor Cristiano
// Descrição:  Saudações
// Autor(a):   Mateus Felipe Gonçalves <contato@mateusf.com>
// Data atual: 23/02/2024
Var
   nome: caractere
   sexo: caractere

Inicio
   escreval("Seu nome")
   escreva("-> ")
   leia(nome)

   escreval("")

   escreval("Seu sexo (apenas letra) | Ex.: M")
   escreval("[M] Masculino")
   escreval("[F] Feminino")
   escreva("-> ")
   leia(sexo)

   escreval("")

   se (sexo = "M") entao
      escreva("Bem Vindo ", nome, "!")
   senao
      escreva("Bem Vinda ", nome, "!")
   fimse

   escreval("")
Fimalgoritmo

Exercício 3

Doar sangue é uma atitude muito importante, entretanto é preciso atender alguns requisitos para poder doar sangue.

• Ter entre 19 e 69 anos de idade
• Pesar ao menos 50 kg
• Não ter feito nenhuma tatuagem no último ano
• Não ter ingerido álcool nas últimas 12 horas.

Desenvolva um software que pergunte ao usuário se ele atende os requisitos necessários para doar sangue. Faça as perguntas uma por vez, caso a resposta dele o impeça de doar, avise-o e encerre o sistema. Se ele atender todos os requisitos, aviseo que ele pode ser doador.

Algoritmo "Doacao"
// Disciplina: Programação Estruturada
// Professor:  Adjenor Cristiano
// Descrição:  Verifica disponibilidade de doação
// Autor(a):   Mateus Felipe Gonçalves <contato@mateusf.com>
// Data atual: 23/02/2024
Var
   idade:          inteiro
   peso:           real
   fez_tatuagem:   caractere
   ingeriu_alcool: caractere

Inicio
   escreval("Sua idade")
   escreva("-> ")
   leia(idade)
   escreval("")

   se ((idade < 19) OU (idade > 69)) entao
      escreval("Você deve ter entre 19 e 69 anos para doar sangue!")
      Fimalgoritmo
   fimse

   escreval("Seu peso (Kg)")
   escreva("-> ")
   leia(peso)
   escreval("")

   se (peso < 50.0) entao
      escreval("Você deve ter pelomenos 50Kg para doar sangue!")
      Fimalgoritmo
   fimse

   escreval("Fez tatuagem no último ano")
   escreva("[sim|nao]-> ")
   leia(fez_tatuagem)
   escreval("")

   se (NAO(fez_tatuagem = "nao")) entao
      escreval("Você não pode doar sangue se tiver feito tatuagem no último ano!")
      Fimalgoritmo
   fimse

   escreval("Ingeriu alcool nas últimas 12 horas")
   escreva("[sim|nao]-> ")
   leia(ingeriu_alcool)
   escreval("")

   se (NAO(ingeriu_alcool = "nao")) entao
      escreval("Você não pode doar sangue se tiver bebido nas últimas 12 horas!")
      Fimalgoritmo
   fimse

   escreval("")
   escreval("Você pode ser um doador!")
   escreval("")
Fimalgoritmo

Exercício 4

Crie um software que ajude a polícia rodoviária federal calcular o valor das multas dos motoristas. O software deve perguntar ao usuário qual a velocidade permitida e qual a velocidade do motorista.
Se o motorista estiver acima da velocidade permitida, o software deve informar qual o tipo de infração e qual o valor da multa. Se o motorista estiver dentro do limite permitido, o programa encerra dizendo que ele não precisa pagar multa. Veja abaixo os valores de multas reajustados de infração por excesso de velocidade:

• Exceder velocidade em até 20% (infração média) = R$85,00 + 4 pontos
• Exceder velocidade de 20 até 50% (infração grave) = R$127,00 + 5 pontos;
• Exceder velocidade acima de 50% (infração gravíssima) = R$574,00 + 7 pontos + apreensão da carteira + suspensão do direito de dirigir.

Algoritmo "CalcularMulta"
// Disciplina: Programação Estruturada
// Professor:  Adjenor Cristiano
// Descrição:  Calcular Multa
// Autor(a):   Mateus Felipe Gonçalves  <contato@mateusf.com>
// Data atual: 23/02/2024
Var
   velocidade_permitida: inteiro
   velocidade_motorista: inteiro
   excedente: real

Inicio
   escreval("Velocidade máxima permitida (Km/h)")
   escreva("-> ")
   leia(velocidade_permitida)
   escreval("")

   escreval("Velocidade do motorista (Km/h)")
   escreva("-> ")
   leia(velocidade_motorista)
   escreval("")

   escreval("---------------------------------")
   escreval("")

   se (velocidade_motorista <= velocidade_permitida) entao
      escreva("Você não precisará pagar multa! ;)")
   senao
      excedente <- ((velocidade_motorista-velocidade_permitida)/velocidade_permitida)*100
      escreval("Você excedeu a velocidade máxima permitida em ", excedente:2:0, "%")
      escreval("")
      se (excedente <= 20.0) entao
         escreval("INFRAÇAO MÉDIA")
         escreval("")

         escreval("Sua multa é de R$85,00")
         escreval("+ 4 pontos")
      senao
         se (excedente <= 50.0) entao
            escreval("INFRAÇAO GRAVE")
            escreval("")

            escreval("Sua multa é de R$127,00")
            escreval("+ 5 pontos")
         senao
            escreval("INFRAÇAO GRAVÍSSIMA")
            escreval("")

            escreval("Sua multa é de R$574,00")
            escreval("+ 7 pontos")
            escreval("Suspensão do direito de dirigir")
         fimse
      fimse
   fimse
Fimalgoritmo

Exercício 5

Uma loja de salgadinhos precisa de ajuda para calcular o valor da conta dos clientes. Crie um programa que leia o código do produto que o cliente comprou e a quantidade e informe a ele quanto ele deverá pagar. Faça uso da estrutura ESCOLHA-CASO. A Tabela abaixo apresenta o código, a descrição e o preço de cada salgadinho.

Algoritmo "CalcularConta"
// Disciplina: Programação Estruturada
// Professor:  Adjenor Cristiano
// Descrição:  Calcula Conta do Cliente
// Autor(a):   Mateus Felipe Gonçalves <contato@mateusf.com>
// Data atual: 23/02/2024
Var
   id_do_produto: inteiro
   quantidade:    real
   total:         real

   loop: caractere

Inicio
   loop <- "sim"

   enquanto (loop = "sim") faca
      loop <- "nao"

      limpatela()
      escreval("+---------------------------------------+")
      escreval("|               SALGADOS                |")
      escreval("|---------------------------------------|")
      escreval("| Cód. |    Salgado    | Valor unitário |")
      escreval("|---------------------------------------|")
      escreval("| [1]  | Coxinha       |     R$0,50     |")
      escreval("| [2]  | Pastel        |     R$0,75     |")
      escreval("| [3]  | Pão de Queijo |     R$0,40     |")
      escreval("| [4]  | Enroladinho   |     R$0,80     |")
      escreval("+---------------------------------------+")
      escreval("")
      escreva("Cód. -> ")
      leia(id_do_produto)
      escreva("Qtd. -> ")
      leia(quantidade)

      escolha id_do_produto
      caso 1
         total <-  quantidade*0.50
      caso 2
         total <-  quantidade*0.75
      caso 3
         total <-  quantidade*0.40
      caso 4
         total <-  quantidade*0.80
      fimescolha

      escreval("")
      escreval("TOTAL: R$", total:4:2)
      escreval("")

      escreval("Nova compra?")
      escreva("[sim|nao]-> ")
      leia(loop)
   fimenquanto
Fimalgoritmo

Aula 4 - VisuAlg

Data: 29/02/2024

Exercício 1

Crie um software que receba do usuário um valor inteiro e imprima na tela o mês do ano correspondente ao valor recebido (ex. recebendo o valor 1, o programa imprime “Janeiro”; recebendo o valor 2, o programa imprime “Fevereiro”...).

Algoritmo "Meses"
// Disciplina  : Programação Estruturada
// Professor   : Adjenor Cristiano
// Descrição   : Imprime o mês referente à um ID
// Autor(a)    : Mateus Felipe Gonçalves
// Data atual  : 03/03/2024
Var
   // Seção de declaração de variáveis
   id: inteiro

Inicio
   // Seção de Comandos, procedimento, funções, operadores, etc...
   escreval("Digite o número do mês")
   escreva("-> ")
   leia(id)

   escreval("")

   escolha(id)
   caso 1
      escreval("Janeiro")
   caso 2
      escreval("Fevereiro")
   caso 3
      escreval("Março")
   caso 4
      escreval("Abril")
   caso 5
      escreval("Maio")
   caso 6
      escreval("Junho")
   caso 7
      escreval("Julho")
   caso 8
      escreval("Agosto")
   caso 9
      escreval("Setembro")
   caso 10
      escreval("Outubro")
   caso 11
      escreval("Novembro")
   caso 12
      escreval("Dezembro")
   outrocaso
      escreval("ID Inválido!")
   fimescolha
Fimalgoritmo

Exercício 2

Crie um software que receba do usuário um valor inteiro de 1 a 10 e imprima na tela o número por extenso. Se o usuário digitar um número maior que 10 ele deve imprimir “Valor Inválido”.

Algoritmo "Numero"
// Disciplina  : Programação Estruturada
// Professor   : Adjenor Cristiano Queiroz
// Descrição   : Número por extenso
// Autor(a)    : Mateus Felipe Gonçalves
// Data atual  : 03/03/2024
Var
   // Seção de declaração de variáveis
   id: inteiro

Inicio
   // Seção de Comandos, procedimento, funções, operadores, etc...
   escreval("Digite o número")
   escreva("-> ")
   leia(id)

   escreval("")

   escolha(id)
   caso 1
      escreval("Um")
   caso 2
      escreval("Dois")
   caso 3
      escreval("Três")
   caso 4
      escreval("Quatro")
   caso 5
      escreval("Cinco")
   caso 6
      escreval("Seis")
   caso 7
      escreval("Sete")
   caso 8
      escreval("Oito")
   caso 9
      escreval("Nove")
   caso 10
      escreval("Dez")
   outrocaso
      escreval("Valor inválido!")
   fimescolha

Fimalgoritmo

Exercício 3

Desenvolva um software que receba o nome do usuário, o sexo, a cidade e o ano que ele nasceu e depois imprima na tela sua ficha cadastral utilizando “Sr” para homens e “Srª” para mulheres.
Considere apenas o ano para cálculo da idade (quem nasceu em 2002 considere que ele tem 22 anos, quem nasceu em 2001 considere 23...)
Ex: Ficha Cadastral
Sr: Adjenor Cristiano Queiroz
Idade: 22 anos
Cidade: Pará de Minas

Algoritmo "Ficha"
// Disciplina  : Programação Estruturada
// Professor   : Adjenor Cristiano
// Descrição   : Imprime o mês referente à um ID
// Autor(a)    : Mateus Felipe Gonçalves
// Data atual  : 03/03/2024
Var
   // Seção de declaração de variáveis
   nome:        caractere
   sexo:        caractere
   cidade:      caractere
   ano_nasc:    inteiro
   comprimento: caractere

Inicio
   escreval("Nome")
   escreva("-> ")
   leia(nome)
   escreval("")

   escreval("Sexo [M|F]")
   escreva("-> ")
   leia(sexo)
   escreval("")

   escreval("Cidade")
   escreva("-> ")
   leia(cidade)
   escreval("")

   escreval("Ano de nascimento")
   escreva("-> ")
   leia(ano_nasc)
   escreval("")

   se ano_nasc > 2024 entao
      escreval("ERRO | O ano de nascimento não pode ser no futuro")
      interrompa()
   fimse

   se maiusc(sexo) = "M" entao
      comprimento <- "Sr."
   senao
      comprimento <- "Srª."
   fimse

   escreval("FICHA CADASTRAL")
   escreval(comprimento, " -- ", nome)
   escreval("Idade --", 2024 - ano_nasc)
   escreval("Cidade - ", cidade)
Fimalgoritmo

Exercício 4

(DESAFIO) Desenvolva um Software para um restaurante que irá mostrar para o usuário um cardápio de refeições (com no mínimo 4 opções) para escolha:

Ex:
1 – Risotto ----- R$ 25,00
2 – Espaguete --- R$ 22,00

Depois pergunte a ele se ele deseja alguma bebida. Se ele desejar, mostre a ele um menu com as opções de bebida (ao menos 4).

Ex:
1 – Coca Cola -------- R$ 5,00
2 – Água Mineral ----- R$ 3,00
Ao final mostre a ele qual o seu pedido e o valor da conta.

Ex: PEDIDO:
Espaguete R$ 22,00
Coca Cola R$ 5,00
TOTAL: R$ 27,00.

Dica: Use uma variável do tipo caractere para armazenar os itens do pedido e uma variável real para armazenar os valores

Algoritmo "Cardápio"
// Disciplina  : Programação Estruturada
// Professor   : Adjenor Cristiano
// Descrição   : Imprime o mês referente à um ID
// Autor(a)    : Mateus Felipe Gonçalves
// Data atual  : 03/03/2024
Var
   prato: inteiro
   bebida: inteiro
   quer_bebida: caractere
   total: real
Inicio
   escreval("------------ PRATOS ------------")
   escreval("[1] Risoto ------------- R$25,00")
   escreval("[2] Espaguete ---------- R$22,00")
   escreval("[3] Strogonoff --------- R$30,00")
   escreval("[4] Macarrão na Chapa -- R$20,00")
   escreval("")
   escreva("-> ")
   leia(prato)
   escreval("")

   escreval("Aceita uma bebida? [S|N]")
   escreva("-> ")
   leia(quer_bebida)
   escreval("")

   se maiusc(quer_bebida) = "S" entao
      escreval("--------- BEBIDAS ---------")
      escreval("[1] Água Mineral -- R$ 3,00")
      escreval("[2] Coca Cola ----- R$ 5,00")
      escreval("[3] Limonada ------ R$ 5,00")
      escreval("[4] Jack&Coffee --- R$25,00")
      escreval("")
      escreva("-> ")
      leia(bebida)
      escreval("")
   fimse

   escreval("---------- PEDIDO ----------")
   escolha(prato)
   caso 1
      total <- 25.00
      escreval("Risoto ------------- R$25,00")
   caso 2
      total <- 22.00
      escreval("Espaguete ---------- R$22,00")
   caso 3
      total <- 30.00
      escreval("Strogonoff --------- R$30,00")
   caso 4
      total <- 20.00
      escreval("Macarrão na Chapa -- R$20,00")
   fimescolha

   se maiusc(quer_bebida) = "S" entao
      escolha(bebida)
      caso 1
         total <- total + 3.00
         escreval("Água Mineral ------- R$ 3,00")
      caso 2
         total <- total + 5.00
         escreval("Coca Cola ---------- R$ 5,00")
      caso 3
         total <- total + 5.00
         escreval("Limonada ----------- R$ 5,00")
      caso 4
         total <- total + 25.00
         escreval("Jack&Coffee -------- R$25,00")
      fimescolha
   fimse

   escreval("")
   escreval("TOTAL: R$", total:2:2)
Fimalgoritmo

Aula 5 - VisuAlg

Data: 05/03/2024

Exercício 1

Desenvolva um software em que receberá alguns números fornecidos pelo usuário, enquanto ele quiser continuar digitando números (a cada interação pergunte ao usuário se ele deseja continuar a soma), e ao final, exiba o resultado da soma dos números digitados na tela.

Algoritmo "SomaNumeros"
// Disciplina  : Programação Estruturada
// Professor   : Adjenor Cristino
// Descrição   : Soma vários números fornecidos pelo usuário
// Autor(a)    : Mateus Felipe Gonçalves <contato@mateusf.com>
// Data atual  : 08/03/2024
Var
   soma:   inteiro
   numero: inteiro
   continuar: caractere
   primeira_interacao: logico

Inicio
   continuar <- "SIM"
   primeira_interacao <- verdadeiro
   numero <- 0
   soma <- 0

   enquanto (maiusc(continuar) = "SIM") faca
      limpatela()

      se(primeira_interacao) entao
         primeira_interacao <- falso

         escreval("Digite um número")
         escreva("-> ")
         leia(numero)
      senao
         escreval("Digite mais um número")
         escreva("-> ")
         leia(numero)
      fimse

      soma <- soma + numero

      escreval()

      escreval("Deseja somar mais um número?")
      escreva("-> ")
      leia(continuar)

   fimenquanto

   limpatela()

   escreval("Resultado da soma:")
   escreval()
   escreval("   [", soma, " ]   ")
Fimalgoritmo

Exercício 2

Desenvolva um software em que receba uma quantidade do usuário e imprima na tela essa quantidade de vezes “Programação é nossa melhor matéria!”.

Algoritmo "ProgramacaoMelhorMateria"
// Disciplina  : Programação Estruturada
// Professor   : Adjenor Cristino
// Descrição   : Imprime uma mensagem N vezes
// Autor(a)    : Mateus Felipe Gonçalves <contato@mateusf.com>
// Data atual  : 08/03/2024
Var
   quantidade: inteiro
   contador: inteiro
   certeza: caractere

Inicio
   certeza   <- "NÃO"
   quantidade <- 0
   contador <- 0

   enquanto ((maiusc(certeza) = "NÃO") OU (maiusc(certeza) = "NAO")) faca
      limpatela()

      escreval("Digite o número de vezes")
      escreva("-> ")
      leia(quantidade)

      se (quantidade > 100) entao
         escreval()
         escreval("A mensagem será repedita", quantidade, " vezes!")
         escreval("Você tem certeza que quer continuar?")
         escreva("-> ")
         leia(certeza)
      senao
         certeza <- "SIM"
      fimse
   fimenquanto

   limpatela()

   enquanto (contador <= quantidade) faca
      contador <- contador + 1
      escreval("Programação é a melhor matéria!")
   fimenquanto

Fimalgoritmo

Exercício 3

Atualize o software do exercício da Lanchonete de modo que o usuário possa fazer um pedido de vários itens no mesmo pedido. Quando ele desejar finalizar o pedido o sistema irá imprimir na tela a lista de produtos comprados e o valor da conta.
Dicas:

• Trabalhe dentro de um laço de repetição enquanto.
• Utilize uma variável do tipo caractere para armazenar os dados do pedido e a cada novo item adicionado, concatene a variável com ela mesma.
  Ex: produtos <- produtos + " 1 - COXINHA: R$ 6,00 | " {:visualg}

Algoritmo "Cardápio"
// Disciplina  : Programação Estruturada
// Professor   : Adjenor Cristiano
// Descrição   : Cardápio de lanchonete
// Autor(a)    : Mateus Felipe Gonçalves <contato@mateusf.com>
// Data atual  : 08/03/2024
Var
   prato:  inteiro
   pedido: caractere
   total:  real
   encerrar: logico
   primeira_iteracao: logico
Inicio
   encerrar <- falso
   primeira_iteracao <- verdadeiro

   enquanto (nao(encerrar)) faca
      limpatela()

      se(primeira_iteracao) entao
         primeira_iteracao <- falso
      senao
         escreval("Quer pedir mais alguma coisa?")
         escreval("Valor total: R$ ", total:2:2)
         escreval()
      fimse

      escreval("------------ PRATOS ------------")
      escreval("[1] Risoto ------------- R$25,00")
      escreval("[2] Espaguete ---------- R$22,00")
      escreval("[3] Strogonoff --------- R$30,00")
      escreval("[4] Macarrão na Chapa -- R$20,00")
      escreval("--------------------------------")
      escreval("[5] ENCERRAR PEDIDO")
      escreval("--------------------------------")
      escreval()
      escreva("-> ")
      leia(prato)

      escolha(prato)
      caso 1
         total <- total + 25.00
         pedido <- pedido + "Risoto - R$25,00 | "
      caso 2
         total <- total + 22.00
         pedido <- pedido + "Espaguete - R$22,00 | "
      caso 3
         total <- total + 30.00
         pedido <- pedido + "Strogonoff - R$30,00 | "
      caso 4
         total <- total + 20.00
         pedido <- pedido + "Macarrão na Chapa - R$20,00 | "
      caso 5
         encerrar <- verdadeiro
      fimescolha
   fimenquanto

   limpatela()

   escreval("-- PEDIDO ------------")
   escreval()
   escreval("| ", pedido)
   escreval()
   escreval("TOTAL: [ R$", total:2:2, " ]")
   escreval()
Fimalgoritmo

Aula 6 - VisuAlg

Data: 12/03/2024

Exercício 1

Escreva um algoritmo para imprimir os 10 primeiros números inteiros maiores que 100.

Algoritmo "DezNumerosMaioresQue100"
// Disciplina  : Programação Estruturada
// Professor   : Adjenor
// Descrição   : Imprime os 10 primeiros números inteiros maiores que 100.
// Autor(a)    : Mateus Felipe Gonçalves <contato@mateusf.com>
// Data atual  : 19/03/2024

Var
    numero: Inteiro
Inicio
    para numero de 100 ate 110 faca
        escreval(numero)
    fimpara
Fimalgoritmo

Exercício 2

Escreva um algoritmo que imprima os números pares de 1 a 100. Utilize o sinal de % para verificar o resto da divisão.

Algoritmo "NumerosParesAte100"
// Disciplina  : Programação Estruturada
// Professor   : Adjenor
// Descrição   : Imprime os números pares de 1 a 100.
// Autor(a)    : Mateus Felipe Gonçalves <contato@mateusf.com>
// Data atual  : 19/03/2024

Var
    numero: Inteiro
Inicio
    para numero de 1 ate 100 faca
        se numero % 2 = 0 entao
            escreval(numero)
        fimse
    fimpara
Fimalgoritmo

Exercício 3

Escreva um algoritmo que pergunte ao usuário quantos números ele quer imprimir na tela. Se o usuário digitar um número maior que 30, interrompa o laço de repetição e imprima na tela uma mensagem para o usuário.

Algoritmo "NumerosPersonalizados"
// Disciplina  : Programação Estruturada
// Professor   : Adjenor
// Descrição   : Pergunta ao usuário quantos números ele
//               quer imprimir e interrompe se for mais que 30.
// Autor(a)    : Mateus Felipe Gonçalves <contato@mateusf.com>
// Data atual  : 19/03/2024

Var
    contador, quantidade: Inteiro

Inicio
    escreval("Quantos números você deseja imprimir?")
    escreva("-> ")
    leia(quantidade)

    para contador de 1 ate quantidade faca
        se quantidade > 30 entao
            escreval("Número muito grande! O máximo permitido é 30.")
            interrompa
        senao
            escreval(contador)
        fimse
    fimpara

Fimalgoritmo

Exercício 4

Escreva um algoritmo receba um número do usuário e imprima na tela os próximos 10 números múltiplos de 5. Utilize o comando INTERROMPA para sair do loop.

Algoritmo "ProximosMultiplosDe5"
// Disciplina  : Programação Estruturada
// Professor   : Adjenor
// Descrição   : Imprime os próximos 10 números múltiplos de 5 a partir de um Número fornecido pelo usuário.
// Autor(a)    : Mateus Felipe Gonçalves <contato@mateusf.com>
// Data atual  : 19/03/2024

Var
    numero, contador: Inteiro

Inicio
    escreva("Digite um Número: ")
    leia(numero)

    para contador de 1 ate 10 faca
        se numero % 5 = 0 entao
            escreval(numero)
            numero <- numero + 5
        senao
            numero <- numero + 1
        fimse
    fimpara
Fimalgoritmo

Exercício 5

Escreva um algoritmo receba do usuário um número, depois receba do usuário uma opção (P para Par ou I para Ímpar) e imprima na tela todos os números de 0 até o número escolhido respeitando a opção escolhida (par ou ímpar). Ex: se o usuário digitar 6 e escolher ímpar, o sistema deve imprimir: 1 - 3 - 5

Algoritmo "ProximosMultiplosDe5"
// Disciplina  : Programação Estruturada
// Professor   : Adjenor
// Descrição   : Imprime os próximos 10 números múltiplos de 5 a partir de um Número fornecido pelo usuário.
// Autor(a)    : Mateus Felipe Gonçalves <contato@mateusf.com>
// Data atual  : 19/03/2024

Var
    numero, contador: Inteiro

Inicio
    escreva("Digite um Número: ")
    leia(numero)

    para contador de 1 ate 10 faca
        se numero % 5 = 0 entao
            escreval(numero)
            numero <- numero + 5
        senao
            numero <- numero + 1
        fimse
    fimpara
Fimalgoritmo

Exercício 6

Reescreva o código do exercício anterior de modo que a impressão dos números seja escrita em ordem decrescente. Ex: se o usuário digitar 6 e escolher ímpar, o sistema deve imprimir: 5 - 3 - 1.

Algoritmo "NumerosParImparDecrescente"
// Disciplina  : Programação Estruturada
// Professor   : Adjenor
// Descrição   : Imprime números pares ou ímpares em ordem decrescente até o Número escolhido pelo usuário.
// Autor(a)    : Mateus Felipe Gonçalves <contato@mateusf.com>
// Data atual  : 19/03/2024

Var
   numero, contador: inteiro
   opcao: caractere

Inicio
   escreva("Digite um Número: ")
   leia(numero)

   escreva("Escolha uma opção (P para Par ou I para ímpar): ")
   leia(opcao)

   para contador de numero ate 0 passo -1 faca
      se (maiusc(opcao) = "P") entao
         se(contador % 2 = 0) entao
            escreval(contador)
         fimse
      senao se (maiusc(opcao) = "I") entao
         se(contador % 2 <> 0) entao
            escreval(contador)
         fimse
      fimse
   fimpara

Fimalgoritmo

Exercício 7

Escreva um algoritmo para pedidos de uma loja de calçados. O algoritmo deve mostrar um menu com ao menos 4 produtos predefinidos e oferecer ao usuário a opção de selecionar mais de um produto ou encerrar o pedido (similar ao exercício do restaurante). Ao final o algoritmo deve mostrar o resumo da compra e o valor total (formatado em reais).

Algoritmo "PedidoLojaCalcados"
// Disciplina  : Programação Estruturada
// Professor   : Adjenor
// Descrição   : Sistema de pedidos de uma loja de calçados.
// Autor(a)    : Mateus Felipe Gonçalves <contato@mateusf.com>
// Data atual  : 19/03/2024

Var
   opcao: caractere
   valor_total: real
Inicio
   valor_total <- 0

   repita
      limpatela()
      escreval("MENU DE PRODUTOS:")
      escreval("1 - Tênis Adidas: R$ 199.99")
      escreval("2 - Chinelo Nike: R$ 49.99")
      escreval("3 - Bota Timberland: R$ 299.99")
      escreval("4 - Sandália Havaianas: R$ 29.99")
      escreval("0 - Encerrar pedido")

      escreva("Escolha um produto ou 0 para encerrar: ")
      leia(opcao)

      escolha opcao
      caso "1"
         valor_total <- valor_total + 199.99
      caso "2"
         valor_total <- valor_total + 49.99
      caso "3"
         valor_total <- valor_total + 299.99
      caso "4"
         valor_total <- valor_total + 29.99
      fimEscolha
   ate opcao = "0"

   limpatela()

   se valor_total > 0 entao
      escreval("RESUMO DA COMPRA:")
      escreval("Valor total: R$", valor_total:0:2)
   senao
      escreval("Nenhum produto foi selecionado. Pedido cancelado.")
   fimse

Fimalgoritmo

Aula 7 - Python

Data: 26/03/2024

Exercício 1

Escreva um programa que leia as três notas do aluno e calcule e imprima no console a média que ele obteve na disciplina.

"""
Lê três notas do aluno, calcula e imprime a média no console.

Aluno:     Mateus Felipe Gonçalves <contato@mateusf.com>
Professor: Adjenor Cristiano
Curso:     Gestão da Tecnologia da Informação
Matéria:   Programação Estruturada
Turma:     1º Período - B
Data:      27/03/2024
"""

# Lê as notas do aluno
nota1 = float(input("Digite a primeira nota: "))
nota2 = float(input("Digite a segunda nota: "))
nota3 = float(input("Digite a terceira nota: "))

# Calcula a média
media = (nota1 + nota2 + nota3) / 3

# Imprime a média
print(f"A média do aluno é {media:.2f}")

Exercício 2

Sabe-se que o m² de construção custa R$850. Escreva um programa que leia as medidas de um terreno retangular e calcula e imprime quanto custa para construir uma casa que ocupe esse terreno.

"""
Programa que lê as medidas de um terreno retangular e calcula e imprime quanto custa
para construir uma casa que ocupe esse terreno. O m² de construção custa R$ 850,00.

Aluno:     Mateus Felipe Gonçalves <contato@mateusf.com>
Professor: Adjenor Cristiano
Curso:     Gestão da Tecnologia da Informação
Matéria:   Programação Estruturada
Turma:     1º Período - B
Data:      27/03/2024
"""

# Lê as medidas do terreno
largura = float(input("Digite a largura do terreno: "))
comprimento = float(input("Digite o comprimento do terreno: "))

# Calcula a área do terreno
area = largura * comprimento

# Calcula o custo da construção
custo = area * 850

# Imprime o custo da construção
print(f"O custo para construir uma casa nesse terreno é R$ {custo:.2f}")

Exercício 3

Escreva um programa que leia o salário total de uma pessoa e quantas horas ela trabalha por dia. Em seguida, calcule e imprima quanto essa pessoa recebe por hora. Considere o mês com 30 dias.

"""
Programa que lê o salário total de uma pessoa e quantas horas ela trabalha por dia.
Em seguida, calcula e imprime quanto essa pessoa recebe por hora.

Aluno:     Mateus Felipe Gonçalves <contato@mateusf.com>
Professor: Adjenor Cristiano
Curso:     Gestão da Tecnologia da Informação
Matéria:   Programação Estruturada
Turma:     1º Período - B
Data:      27/03/2024
"""

# Lê o salário total
salario = float(input("Digite o salário total\n-> "))

# Lê a quantidade de horas trabalhadas por dia
horas_por_dia = float(input("Digite a quantidade de horas trabalhadas por dia\n-> "))

# Calcula horas trabalhadas no mês
horas_por_mes = horas_por_dia * 30

# Calcula o valor da hora
valor_hora = salario / horas_por_mes

# Imprime o valor da hora
print(f"\nO valor da hora é R$ {valor_hora:.2f}")

Exercício 4

Escreva um programa que peça ao usuário para informar o peso e a altura com o comando leia, depois calcule e imprima na tela o IMC dessa pessoa sabendo que a fórmula do IMC é (peso/altura²).

"""
Programa que pede ao usuário para informar o peso e a altura com o comando leia, depois
calcula e imprime na tela o IMC dessa pessoa sabendo que a fórmula do IMC é (peso/altura²).

Aluno:     Mateus Felipe Gonçalves <contato@mateusf.com>
Professor: Adjenor Cristiano
Curso:     Gestão da Tecnologia da Informação
Matéria:   Programação Estruturada
Turma:     1º Período - B
Data:      27/03/2024
"""

# Lê o peso
peso = float(input("Digite o peso (kg)\n-> "))

# Lê a altura
altura_cm = float(input("Digite a altura (cm)\n-> "))

# Calcula o IMC
imc = peso / (altura_cm/100) ** 2

# Imprime o IMC
print(f"\nO IMC é {imc:.2f}")

Aula 8 - Python

Data: 02/04/2024

Exercício 1

Desenvolva um software que receba uma string do usuário e depois solicite a ele quantas letras da string ele quer que sejam separadas, depois imprima na tela as duas partes da string.
EX: se o usuário digitar “Faculdade” e o número 5, o software deve retornar:
Primeira Parte: “Facul”
Segunda Parta: “dade”

class bcolors:
    HEADER = '\033[95m'
    OKBLUE = '\033[94m'
    OKCYAN = '\033[96m'
    OKGREEN = '\033[92m'
    WARNING = '\033[93m'
    FAIL = '\033[91m'
    ENDC = '\033[0m'
    BOLD = '\033[1m'
    UNDERLINE = '\033[4m'

text = input("Texto a ser dividido: ")
position = input("Posição de divisão da string: ")

if not text or not position:
    print(f"\n{bcolors.FAIL}Quantidade de parâmetros insuficientes ou inválidos!{bcolors.ENDC}")
    quit()

position = int(position)

if position > len(text):
    print(f"\n{bcolors.FAIL}Posição de divisão maior que o tamanho do texto!{bcolors.ENDC}")
    print(f"Tamanho do texto: {bcolors.BOLD}{len(text)}{bcolors.ENDC}")
    print(f"Posição de divisão: {bcolors.BOLD}{position}{bcolors.ENDC}")
    quit()

first_part, second_part = text[:position], text[position:]

print(f"\n{bcolors.OKGREEN}Primeira parte:{bcolors.ENDC} {bcolors.BOLD}{first_part}{bcolors.ENDC}")
print(f"{bcolors.OKGREEN}Segunda parte:{bcolors.ENDC}  {bcolors.BOLD}{second_part}{bcolors.ENDC}")

Exercício 2

Desenvolva um software que receba do usuário seu nome, seu sobrenome e uma quantidade. Depois solicite a ele quantas vezes ele deseja imprimir o conjunto (nome e sobrenome) e imprima na tela essa quantidade de vezes. Utilize \n para quebra de linha.

from os import system, name

nome = input("Digite seu nome: ")
sobrenome = input("Digite seu sobrenome: ")
n = int(input("Número de repetições: "))

# limpa terminal
if name == 'nt':
    # windows
    system('cls')
else:
    # outros unix (linux, mac...)
    system('clear')

for i in range(n):
    print(f"{nome} {sobrenome}")

Exercício 3

Desenvolva um software que receba do usuário um valor e imprima na tela este valor formatado para reais (R$) utilizando composição.

valor = float(input('Digite o valor: '))
print("R$ %.2f"%valor)

Exercício 4

Desenvolva um software que receba do usuário um valor de compra, depois receba um valor em dinheiro e calcule o troco e imprima na tela este valor formatado para reais (R$) utilizando composição.

valor_compra = float(input('Digite o valor da compra: '))
valor_pago = float(input('Digite o valor pago: '))

troco = valor_pago - valor_compra

if troco < 0:
    print('\nValor pago insuficiente, falta R$ %.2f.'%abs(troco))
else:
    print('\nTroco: R$ %.2f'%troco)

Aula 9 - Python

Data: 09/04/2024

Exercício 1

Desenvolva um software que leia dois números e que pergunte qual operação você deseja realizar. Você deve poder calcular a soma (+), subtração (-), multiplicação (*) e divisão (/). Exiba o resultado da operação solicitada.

"""
Nome:      Mateus Felipe Gonçalves <contato@mateusf.com>
Professor: Adjenor Cristiano
Data:      10/04/2024
Matéria:   Programação Estruturada
Turma:     1º Perí. B
"""

# lê dois números e uma operação
num1 = float(input("Digite o primeiro número: "))
num2 = float(input("Digite o segundo número: "))
operacao = input("Digite a operação [+|-|*|/]: ")

# exiba o resultado da operação solicidada
if operacao == "+":
    print(f"O resultado da soma é: {num1 + num2}")
elif operacao == "-":
    print(f"O resultado da subtração é: {num1 - num2}")
elif operacao == "*":
    print(f"O resultado da multiplicação é: {num1 * num2}")
elif operacao == "/":
    # 0 não pode ser dividido
    if num2 == 0:
        print("Não é possível dividir por zero.")
    else:
        print(f"O resultado da divisão é: {num1 / num2}")
else:
    print("Operação inválida.")

Exercício 2

Desenvolva um software para aprovar o empréstimo bancário para compra de uma casa. O programa deve perguntar o valor da casa a comprar, o salário e a quantidade de anos a pagar. O valor da prestação mensal não pode ser superior a 30% do salário. Calcule o valor da prestação como sendo o valor da casa a comprar dividido pelo número de meses a pagar.

"""
Nome:      Mateus Felipe Gonçalves <contato@mateusf.com>
Professor: Adjenor Cristiano
Data:      10/04/2024
Matéria:   Programação Estruturada
Turma:     1º Perí. B
"""

valor_casa = float(input("Digite o valor da casa: R$ ").strip().replace(",", "."))
salario = float(input("Digite o salário: R$ ").strip().replace(",", "."))
anos = int(input("Digite a quantidade de anos a pagar: "))

meses = anos * 12

prestacao = valor_casa / meses

if prestacao > (salario * 0.3):
    print("Empréstimo negado.")
else:
    print(f"Empréstimo aprovado. A prestação será de R$ {prestacao:.2f}.")

Exercício 3

Desenvolva um software de lanchonete que apresente para o cliente um menu com ao menos 4 opções de salgado para que ele escolha, depois apresente ao menos 4 opções de bebidas. Ao final, o software deve mostrar na tela o valor total da compra e os itens comprados.

"""
Nome:      Mateus Felipe Gonçalves <contato@mateusf.com>
Professor: Adjenor Cristiano
Data:      10/04/2024
Matéria:   Programação Estruturada
Turma:     1º Perí. B
"""

# menu com 4 opções de salgados
print("+------ MENU SALGADOS -------+")
print("| [1] Coxinha ------ R$ 3,50 |")
print("| [2] Pastel ------- R$ 4,00 |")
print("| [3] Empada ------- R$ 3,00 |")
print("| [4] Enroladinho -- R$ 2,50 |")
print("+----------------------------+")
salgado = int(input("-> "))

if salgado < 1 or salgado > 4:
    print("Opção inválida.")
    exit()

# menu com 4 opções de bebidas
print("\n+------ MENU BEBIDAS --------+")
print("| [1] Refrigerante - R$ 3,00 |")
print("| [2] Suco --------- R$ 2,50 |")
print("| [3] Água --------- R$ 2,00 |")
print("| [4] Chá ---------- R$ 2,50 |")
print("+----------------------------+")
bebida = int(input("-> "))

if bebida < 1 or bebida > 4:
    print("Opção inválida.")
    exit()

# cálculo do valor total
total = 0

if salgado == 1:
    total += 3.50
elif salgado == 2:
    total += 4.00
elif salgado == 3:
    total += 3.00
elif salgado == 4:
    total += 2.50

if bebida == 1:
    total += 3.00
elif bebida == 2:
    total += 2.50
elif bebida == 3:
    total += 2.00
elif bebida == 4:
    total += 2.50

print("\nTotal a pagar: R$ %.2f" % total)

Exercício 4

Desenvolva um software para analisar se um aluno foi aprovado. O software deve receber 4 notas (entre 0 e 25) e ao final atestar as seguintes possibilidades:

• Se o total for maior ou igual 80 - ALUNO APROVADO - EXCELENTE
• Se o total for entre 60 e 79 - ALUNO APROVADO
• Se o total for entre 40 e 59 - ALUNO EM RECUPERAÇÃO
• Se o total for menor que 40 - ALUNO REPROVADO
• Se alguma das notas estiver fora do intervalo (entre 0 e 25) o software deve exibir a mensagem de “Valor inválido” e encerrar.

"""
Nome:      Mateus Felipe Gonçalves <contato@mateusf.com>
Professor: Adjenor Cristiano
Data:      11/04/2024
Matéria:   Programação Estruturada
Turma:     1º Perí. B
"""

nota1 = float(input("Nota 1: "))
nota2 = float(input("Nota 2: "))
nota3 = float(input("Nota 3: "))
nota4 = float(input("Nota 4: "))

if nota1 < 0 or nota1 > 25:
    print("Valor inválido.")
    exit()
elif nota2 < 0 or nota2 > 25:
    print("Valor inválido.")
    exit()
elif nota3 < 0 or nota3 > 25:
    print("Valor inválido.")
    exit()
elif nota4 < 0 or nota4 > 25:
    print("Valor inválido.")
    exit()

total = nota1 + nota2 + nota3 + nota4

if total >= 80:
    print("ALUNO APROVADO - EXCELENTE")
elif total >= 60:
    print("ALUNO APROVADO")
elif total >= 40:
    print("ALUNO EM RECUPERAÇÃO")
else:
    print("ALUNO REPROVADO")

Exercício 5

Escreva um programa que calcule o preço pelo fornecimento de energia elétrica. Pergunte a quantidade de kWh consumidos e o tipo de instalação: R para residências, I para indústrias e C para comércios. Calcule o preço a pagar de acordo com a tabela a seguir:

• Residências:
  • Até 500 kWh: R$ 0,40
  • Acima de 500 kWh: R$ 0,65
• Comércios:
  • Até 1000 kWh: R$ 0,55
  • Acima de 1000 kWh: R$ 0,60
• Indústrias:
  • Até 5000 kWh: R$ 0,55
  • Acima de 5000 kWh: R$ 0,60

"""
Nome:      Mateus Felipe Gonçalves <contato@mateusf.com>
Professor: Adjenor Cristiano
Data:      11/04/2024
Matéria:   Programação Estruturada
Turma:     1º Perí. B
"""

kwh = int(input("Quantidade de kWh consumido: "))

print("\n+- TIPO DE INSTALAÇÃO -+")
print("|  [R] Residencial     |")
print("|  [C] Comercial       |")
print("|  [I] Industrial      |")
print("+----------------------+")
instalacao = input("-> ").upper()

total = 0
if instalacao == "R":
    if kwh <= 500:
        total = kwh * 0.40
    else:
        total = kwh * 0.65
elif instalacao == "C":
    if kwh <= 1000:
        total = kwh * 0.55
    else:
        total = kwh * 0.60
elif instalacao == "I":
    if kwh <= 5000:
        total = kwh * 0.55
    else:
        total = kwh * 0.60
else:
    print("Tipo de instalação inválido.")
    exit()

print("\nTotal a pagar: R$ %.2f" % total)

Aula 10 - Python

Data: 16/04/2024

Exercício 1

Desenvolva um software que receba do usuário uma quantidade e imprima na tela todos os números pares de 0 até o número digitado.

"""
Nome:      Mateus Felipe Gonçalves <contato@mateusf.com>
Professor: Adjenor Cristiano
Data:      21/04/2024
Matéria:   Programação Estruturada
Turma:     1º Perí. B
"""

limite = int(input("Digite um número\n-> "))

for n in range(0, limite+1, 2):
  print(n)

Exercício 2

Altere o software do exercício anterior para que o sistema receba também um tipo (P para Pares e I para Impares) e imprima apenas os números de acordo com a escolha.

"""
Nome:      Mateus Felipe Gonçalves <contato@mateusf.com>
Professor: Adjenor Cristiano
Data:      21/04/2024
Matéria:   Programação Estruturada
Turma:     1º Perí. B
"""

limite = int(input("Digite um número\n-> "))
opcao = input("\nOpção | [P]ar ou [I]mpar\n-> ").upper()

print()

if opcao == "P":
  for i in range(0, limite+1, 2):
    print(i)
elif opcao == "I":
  for i in range(1, limite+1, 2):
    print(i)

Exercício 3

Valide a opção digitada, caso o usuário digite um valor diferente se P ou I, solicite a ele que digite novamente. DICA: Utilize repetições aninhadas.

"""
Nome:      Mateus Felipe Gonçalves <contato@mateusf.com>
Professor: Adjenor Cristiano
Data:      21/04/2024
Matéria:   Programação Estruturada
Turma:     1º Perí. B
"""

limite = int(input("Digite um número\n-> "))

opcoes_validas = ["P", "I"]
opcao = ""
while opcao not in opcoes_validas:
  opcao = input("\nOpção | [P]ar ou [I]mpar\n-> ").upper()

  if opcao not in opcoes_validas:
    print("Opção inválida. Tente novamente.")

print()

if opcao == "P":
  for i in range(0, limite+1, 2):
    print(i)
elif opcao == "I":
  for i in range(1, limite+1, 2):
    print(i)

Exercício 4

Escreva um programa que leia um número e verifique se é ou não um número primo. Para fazer essa verificação, calcule o resto da divisão do número por 2 e depois por todos os números ímpares até o número lido. Se o resto de uma dessas divisões for igual a zero, o número não é primo. Observe que 0 e 1 não são primos e que 2 é o único número primo que é par.

import sys

"""
Nome:      Mateus Felipe Gonçalves <contato@mateusf.com>
Professor: Adjenor Cristiano
Data:      21/04/2024
Matéria:   Programação Estruturada
Turma:     1º Perí. B
"""

def e_primo(primo: bool = True):
  if primo:
    print(f"{numero} é primo.")
  else:
    print(f"{numero} não é primo.")

  sys.exit()

numero = int(input("Digite um número\n-> "))

if numero < 2:
  e_primo(primo=False)

primo = True
for i in range(2, numero):
  if numero % i == 0:
    primo = False
    break

e_primo(primo)

Exercício 5

Desenvolva um software de restaurante que apresente ao menos 4 tipos de produtos e a opção de finalizar o pedido. O software deve perguntar ao usuário se ele deseja adicionar outro produto Ao final ele deve mostrar na tela todos os produtos que o cliente comprou e o total do pedido.
DICA: Utilize uma variável String para armazenar os produtos escolhidos e uma variável float para armazenar o total do pedido. Apresente o total formatado para Real.

"""
Nome:      Mateus Felipe Gonçalves <contato@mateusf.com>
Professor: Adjenor Cristiano
Data:      21/04/2024
Matéria:   Programação Estruturada
Turma:     1º Perí. B
"""

total = 0.0
pedidos = []

while True:
  print("\n+" + " Cardápio ".center(31, "-") + "+")
  print("| [1] Hambúrguer ----- R$ 10.00 |")
  print("| [2] Pizza ---------- R$ 20.00 |")
  print("| [3] Refrigerante --- R$ 5.00  |")
  print("| [4] Batata Frita --- R$ 8.00  |")
  print("| [5] FINALIZAR PEDIDO          |")
  print("+" + "".center(31, "-") + "+")
  escolha = int(input("Escolha uma opção\n-> "))

  if escolha == 1:
    total += 10.00
    pedidos.append("Hambúrguer")
  elif escolha == 2:
    total += 20.00
    pedidos.append("Pizza")
  elif escolha == 3:
    total += 5.00
    pedidos.append("Refrigerante")
  elif escolha == 4:
    total += 8.00
    pedidos.append("Batata Frita")
  elif escolha == 5:
    break

print("\n" + "+" + " Pedido ".center(31, "-") + "+")

for pedido in pedidos:
  print(f"| {pedido} ".ljust(32, " ") + "|")

print("+" + "".center(31, "-") + "+")
print(f"| Total: R$ {total:.2f} ".ljust(32, " ") + "|")
print("+" + "".center(31, "-") + "+")

Aula 11 - Python

Data: 23/04/2024

Exercício 1

Altere o software do Exemplo I de modo que ele agora receba as notas do usuário e calcule a média e mostre na tela um resumo das notas.
DICA: inicie a lista de notas zerada: notas=[0,0,0,0,0] {:python}

Utilize duas estruturas while {:python}

"""
Nome:      Mateus Felipe Gonçalves <contato@mateusf.com>
Professor: Adjenor Cristiano
Data:      29/04/2024
Matéria:   Programação Estruturada
Turma:     1º Perí. B
"""

notas = [0,0,0,0,0]

indice = 0
while indice < 5:
    notas[indice] = int(input('Nota %d: ' % (indice + 1)))
    indice += 1

soma = 0
x = 0

while x < 5:
    soma += notas[x]
    x += 1

print()

print("*"*22)
print("*", "RESUMO DAS NOTAS".center(18), "*")
print("*"*22)

print()


indice = 0
while indice < 5:
    print('Nota %d: %d' % (indice + 1, notas[indice]))
    indice += 1

print('Média: %5.2f' % (soma / x))

Exercício 2

Altere o software do restaurante desenvolvido na semana passada de modo que a cada interação o software mostrará para o cliente todos os produtos comprados e o total da compra. O software deve permitir a ele que ele remova produtos ou adicione mais produtos.
DICA: Utilize ao menos duas listas, uma para os produtos e outra para os valores.

"""
Nome:      Mateus Felipe Gonçalves <contato@mateusf.com>
Professor: Adjenor Cristiano
Data:      29/04/2024
Matéria:   Programação Estruturada
Turma:     1º Perí. B
"""

pratos = [
  "Hambúrguer",
  "Pizza",
  "Refrigerante",
  "Batata Frita"
]

valores = [
  10.00,
  20.00,
  5.00,
  8.00
]

total = 0.0
pedido = []

while True:
  print("\n+" + " Menu ".center(22, "-") + "+")
  print("| [1] Adicionar prato  |")
  print("| [2] Remover prato    |")
  print("| [3] FINALIZAR PEDIDO |")
  print("+" + "-"*22 + "+")
  escolha = int(input("Escolha uma opção\n-> "))

  if escolha == 1:
    # ADICIONAR PEDIDO

    print("\n+" + " Cardápio ".center(28, "-") + "+")

    indice = 0
    while indice < len(pratos):
      opcao = f"[{indice + 1}] {pratos[indice]} - R$ {valores[indice]:.2f}"
      print("|", opcao.ljust(26, " "), "|")
      indice += 1

    print("+" + "".center(28, "-") + "+")
    prato = int(input("Escolha um prato\n-> ")) - 1
    total += valores[prato]
    pedido.append(pratos[prato]) # adiciona um elemeto à lista

  elif escolha == 2:
    # REMOVER PEDIDO

    print("\n+" + " Pedidos ".center(28, "-") + "+")

    indice = 0
    while indice < len(pedido):
      opcao = f"[{indice + 1}] {pedido[indice]}"
      print("|", opcao.ljust(26, " "), "|")
      indice += 1

    print("+" + "".center(28, "-") + "+")

    prato = int(input("Escolha um prato para remover\n-> ")) - 1
    total -= valores[prato]
    del pedido[prato] # OU pedido.pop(prato) # remove um elemento da lista

  elif escolha == 3:
    break
  else:
    print("Opção inválida")


# resulmo do pedido e valor total
print("\n+" + " Pedido ".center(25, "-") + "+")

indice = 0
while indice < len(pedido):
  print(f"| {pedido[indice]} ".ljust(26, " ") + "|")
  indice += 1

# exibe o valor total antes de encerrar o quadro
print("+" + "".center(25, "-") + "+")
print(f"| Total: R$ {total:.2f} ".ljust(26, " ") + "|")
print("+" + "".center(25, "-") + "+")

Exercício 3

Faça um programa que leia duas listas e que gere uma terceira com os elementos das duas primeiras.

"""
Nome:      Mateus Felipe Gonçalves <contato@mateusf.com>
Professor: Adjenor Cristiano
Data:      29/04/2024
Matéria:   Programação Estruturada
Turma:     1º Perí. B
"""

L1 = [7,5,3]
L2 = [4,6,8]

resultado = L1[:] + L2[:]

print(L1) # [7, 5, 3]
print(L2) # [4, 6, 8]
print(resultado) # [7, 5, 3, 4, 6, 8]

Exercício 4

Faça um programa que percorra duas listas e gere uma terceira sem elementos repetidos.

"""
Nome:      Mateus Felipe Gonçalves <contato@mateusf.com>
Professor: Adjenor Cristiano
Data:      29/04/2024
Matéria:   Programação Estruturada
Turma:     1º Perí. B
"""

L1 = [7,5,3,1,2,9]
L2 = [1,4,9,8,3,6]

resultado = list(set(L1 + L2))

print(L1) # [7, 5, 3, 1, 2, 9]
print(L2) # [1, 4, 9, 8, 3, 6]
print(resultado) # [1, 2, 3, 4, 5, 6, 7, 8, 9]

Aula 12 - Python

Aula 13 - Python

Data: 14/05/2024

Exercício 1

Altere o programa anterior de modo que ele receba os valores para preencher a lista, a cada valor digitado o sistema ofereça ao usuário a opção de imprimir a lista com seus índices ([0] - 4). O programa também deve oferecer ao usuário a opção de adicionar mais um valor ou excluir um valor. Ao finalizar o sistema deve apresentar na tela todos os números digitados, o maior, menor e a média.

# verificação do maior valor
lista = []


while True:
    novo_valor = int(input("Digite um valor: "))
    lista.append(novo_valor)
    print("")

    exibir = input("Deseja exibir a lista? (s/n)")

    if exibir == "s":
        print(f"(I) N")
        for cont, item in enumerate(lista):
            print(f"({cont}) {item}")

    print("Escolha uma opção:")
    print("[1]> Adicionar novo valor")
    print("[2]> Excluir valor")
    print("[3]> Finalizar")
    escolha = int(input("-> "))

    print("")
    if escolha == 1:
        continue
    elif escolha == 2:
        print(f"(I) N")
        for cont, item in enumerate(lista):
            print(f"({cont}) {item}")
        excluir = int(input("Digite o índice do valor que deseja excluir: "))
        del lista[excluir]
    elif escolha == 3:
        break


maior = 0
menor = 0
soma = 0

for cont, item in enumerate(lista):
    if (item > maior) or cont == 0:
        maior = item

for cont, item in enumerate(lista):
    if (item < menor) or cont == 0:
        menor = item

for item in lista:
    soma += item


for cont, item in enumerate(lista):
    print(f"({cont}) {item}")

print(f"O maior valor é: {maior}")
print(f"O menor valor é: {menor}")
print(f"A média dos valores é: {soma / len(lista)}")

Exercício 2

Desenvolva um programa para separar os valores da lista [9,8,7,12,0,13,21,35,6,11,1] em duas listas, uma com os pares e outra com os ímpares.

lista = [9,8,7,12,0,13,21,35,6,11,1]

pares = []
impares = []

for item in lista:
    if item % 2 == 0:
        pares.append(item)
    else:
        impares.append(item)

print(f"Pares: {pares}")
print(f"Ímpares: {impares}")

Exercício 3

Altere o software do exercício anterior de forma que ele receba os dados do usuário para criar na lista de compras. O sistema deve oferecer ao usuário a possibilidade de exibir a lista de compras, adicionar e remover itens, além de mostrar os totais (valor total da compra e quantidade total de ítens).

import os
from time import sleep

limpar = lambda: os.system("clear")

itens = []

while True:
    limpar()
    print("+-- MENU PRINCIPAL --+")
    print("| [1] Adicionar item |")
    print("| [2] Remover item   |")
    print("| [3] Listar itens   |")
    print("| [4] Sair           |")
    print("+--------------------+")
    opcao = input("-> ")

    if not opcao.isdigit():
        print("\nOpção inválida!")
        sleep(2)
        continue

    opcao = int(opcao)

    if opcao == 1:
        limpar()

        print("[ ADICIONAR ITEM ]\n")

        nome = input("Nome do item: ")
        quantidade = int(input("Quantidade: "))
        valor_unitario = float(input("Valor unitário: ").replace(",", "."))

        itens.append([nome, quantidade, valor_unitario])

        print("\nItem adicionado com sucesso!")
        sleep(2)
    elif opcao == 2:
        limpar()

        if len(itens) == 0:
            print("Nenhum item para remover!")
            sleep(2)
            continue

        print("[ REMOVER ITEM ]\n")

        print("[ID] Nome\n")
        for indice, item in enumerate(itens):
            print("[%d] %s" % (indice, item[0]))

        print("\nID do ítem que deseja remover")
        id_item = int(input("-> "))

        if id_item < 0 or id_item >= len(itens):
            print("\nID inválido!")
            sleep(2)
            continue
        else:
            del itens[id_item]
            print("\nItem removido com sucesso!")
            sleep(2)
    elif opcao == 3:
        limpar()

        print("[ ITENS ]\n")

        quantidade_total = 0
        valor_total = 0

        print("ID | Nome - Quantidade - Valor unitário (Valor total)")
        print("---|-----------------------------------------------")
        for indice, item in enumerate(itens):
            print("%d  | %s - %d unidade(s) - R$ %.2f (R$ %.2f)" % (indice, item[0], item[1], item[2], item[1] * item[2]))
            quantidade_total += item[1]
            valor_total += item[1] * item[2]

        print("\nQuantidade unitária de itens -- %d" % len(itens))
        print("Quantidade total de itens ----- %d" % quantidade_total)
        print("Valor total da compra --------- R$ %.2f" % valor_total)

        input("\nPressione enter para continuar...")
    elif opcao == 4:
        limpar()
        break
    else:
        print("\nOpção inválida!")
        sleep(2)

Diferences between setState methods

Before all, let's see the difference between the state update methods treated here.

Normal States Updates

import React, { useState } from 'react'

const Counter = () => {
  const [count, setCount] = useState(0);

  const increment = () => {
    setCount(count + 1);
  };

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={increment}>Increment</button>
    </div>
  );
};

export default Counter;

Functional State Updates

import React, { useState } from 'react'

const Counter = () => {
  const [count, setCount] = useState(0);

  const increment = () => {
    setCount((prevCount) => prevCount + 1);
  };

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={increment}>Increment</button>
    </div>
  );
};

export default Counter;

When use functional state updates

The need for functional state updates arises from the problem of stale state and ensuring accurate state transitions. In normal state updates, subsequent state updates are based on the previous state value. However, when dealing with asynchronous updates or multiple state updates within a single function or event handler, the current state may not be up to date. This can lead to inconsistencies and unexpected behavior in your application.

Problem

I.e., suppose you have a component that increments the count by 10 three times when a button is clicked:

import React, { useState } from 'react'

const Counter = () => {
  const [count, setCount] = useState(0);

  const increment = () => {
    setCount(count + 10);
    setCount(count + 10);
    setCount(count + 10);
  };

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={increment}>Increment</button>
    </div>
  );
};

export default Counter;

In this case, you might expect the count to increase by 30 after three button clicks. However, due to the nature of normal state updates, the value of count will only increase by 10, as each setCount call operates on the stale value of count.

Solution

Functional state updates solve this problem by providing the previous state value as an argument within the updater function.
To fix the example above using functional state updates, you can modify the increment function as follows:

const increment = () => {
  setCount((prevCount) => prevCount + 10);
  setCount((prevCount) => prevCount + 10);
  setCount((prevCount) => prevCount + 10);
};

Referencies

Updating state based on the previous state (oficial React docs): https://react.dev/reference/react/useState#updating-state-based-on-the-previous-state

Primeiro recordamos que números pares são os inteiros $\pm2, \pm4, \pm6, \pm8,...$, que podem ser escritos na forma $2n$ para algum inteiro $n$. Um número ímpar é um inteiro como $\pm1, \pm3, \pm5, \pm7,...$, que pode ser escrito na forma $2n+1$ para algum inteiro $n$. Então $6=2\cdot3$ é par (escolhemos $n=3$) e $11=2\cdot5+1$ é ímpar (escolhemos $n=5$).

Observamos que o quadrado de um número par é par. Com efeito, se $n$ é um inteiro e $2n$ é um número par, então

é um número par, que pode ser escrito $2(2n²)$, o produto de $2$ pelo inteiro $2n²$.

O quadrado de um número ímpar é ímpar. Para provar isso, seja $2n+1$ um número ímpar ($n$ sendo um inteiro). Então seu quadrado é

Como $2n²+2n$ é um inteiro, obtivemos o quadrado de nosso número ímpar na forma $2m+1$ para algum inteiro $m$, e então mostramos que seu quadrado é ímpar.

Prova

Estamos agora prontos para provar que a raiz quadrada de 2 não é um número racional. Suponhamos que seja. Isso significa que podemos achar um número racional $a$, tal que $a²=2$. Podemos escrever

onde $m,n$ são inteiros, e nem $m$ nem $n$ é $0$. Além disso, podemos supor $m$, $n$ não simultaneamente pares porque, dividindo-os por $2$ quanto possível, podemos cancelar as potências de $2$ de pelo menos um deles. Assim, podemos admitir que $m$ ou $n$ é ímpar.

Da hipótese de que $a²=2$ obtemos $(m/n)^2=2$, ou

Multiplicando ambos os membros desta equação por $n²$ obtemos

e $m²$ é então par. Pelo que vimos acima, isto significa que $m$ é par e podemos escrever $m=2k$ para algum inteiro $k$. Substituindo, obtemos

ou $4k²=2n^2$. Cancelamos o $2$ e obtemos $2k²=n²$. Isto significa que $n²$ é par e, consequentemente, pelo que vimos acima, que $n$ é par. Concluímos assim que $m$ e $n$ são pares, o que contradiz o fato de que pelo menos um deles é ímpar. Podemos então concluir que não existe nenhuma fração $m/n$ cujo quadrado seja $2$.

I had a component in my website for search through my blog posts, the component consisted in a modal with a search input on top, and the list of posts after the input, here is an screenshot:

The modal is triggered by an button that looks like another input search (but isn't) with a keyboard shortcut (Ctrl+K).

All of this was made using Tailwindcss, Phosphor icons, Radix UI and Geist UI (for the keyboard shortcut) on Next.js.

The initial post list is a random list, then, when a search input is detected, a function is called, for get the input and return the matched post. This function is the main topic of this post.

I'm dropping this implementation now, for use a more better, modern and complete alternative: The kbar library.

I will not talk about kbar now, but I prefer to use him instead of my own, pure, implementation of search modal, but I sincerely like my search function, is simple, and precise. I think that there is better search algorithm that will fit better in my use case, but is my first search function, and I want to register/archive my implementation. If you know another search algorith, feel free to share in the comments section bellow, any link, reference, topic... Anything!

Well, here is:

import { Post } from 'contentlayer/generated'
import { slug } from '@/shared/lib/slug'

export function searchMath(post: Post, search: string) {
  const sluggedSearch = slug(search)

  let weight = 0
  const sources = [
    post.title,
    post.description,
    post.author,
    post.category,
    post.status,
    post.tags
  ]

  sources.forEach(source => slug(source).includes(sluggedSearch) && weight++)

  return weight
}

Well, let me explain...

The Post here is an interface for my defined Post on contentlayer, it's not relevant to write a detailed explanation about it, but you can check the types of the properties bellow:

The slug function is just to get a string and return a slugged version of it (e.g. "Clube Atlético Mineiro" to "clube-atletico-mineiro").

The logic is to attach a weight to the post, that represents how close the post is to the target search, using a weight number between 0-n (n is the number of sources to consider, in this case is 6). With a list of Posts and their respective weights, we can purge all the posts with weight 0 (posts that not match the search) and sort the rest based on weight value, from biggest value (most matching post) to lowest value (least matching post).

Implementation: https://github.com/mateusfg7/mateusf.com/blob/7.3.0/src/shared/lib/match.ts

My mistake

While I was reading my code, I notice that the search isn't case-sensitive, because I transform all to a slug version, and compare this slugged version of the strings.

This ends up decreasing the accuracy of the search, and this "String Processor" it's useless, in fact, it just gets in the way.

I process all the string with the slug function because I already had problems with compare string without process on post titles to get the reference of posts, but this it's not the case.

Moral of the story: beware of "muscle memory" of your brain!

Observation

I was not honest when I said this is my first search implementation, I made another before, but it not have the concept of weight, is just a match script. This script it's self explanatory, so I won't go into details about how it works:

import { Post } from 'contentlayer/generated'
import { slug } from './utils'

export function searchMath(post: Post, search: string) {
  const sluggedSearch = slug(search)

  if (slug(post.title).includes(sluggedSearch)) return true
  if (slug(post.description).includes(sluggedSearch)) return true
  if (slug(post.author).includes(sluggedSearch)) return true
  if (slug(post.category).includes(sluggedSearch)) return true
  if (slug(post.status).includes(sluggedSearch)) return true
  if (slug(post.tags).includes(sluggedSearch)) return true

  return false
}

Implementation: https://github.com/mateusfg7/mateusf.com/blob/6.0.0/src/lib/match.ts

Em 2002, O Prêmio Nobel de economia foi concedido a um cientista chamado Daniel Kahneman. Hoje em dia, os economistas fazem todo tipo de coisa - explicam porque os professores recebem salários tão baixos, porquê os times de futebol valem tanto dinheiro e porque as funções corporais ajudam a estabelecer um limite para o tamanho das criações de porcos (um porco produz de três a cinco vezes mais excrementos que uma pessoa, portanto uma fazendinha com milhares de porcos costuma produzir mais detritos que as cidades vizinhas). Apesar das grandes pesquisas feitas por economistas, o Nobel de 2002 foi excepcional, porque Kahneman não é economista. É psicólogo, e durante décadas, ao lado do falecido Amos Tversky, estudou e esclareceu os tipos de percepções equivocadas sobre a aleatoriedade que alimentam muitas das falácias comuns de que falarei neste livro.

O maior desafio à compreensão do papel da aleatoriedade na vida é o fato de que, embora os princípios básicos dela surjam da lógica cotidiana, muitas das consequências que se seguem a esses princípios provam-se contra intuitivas. Os próprios estudos de Kahneman e Tversky foram desencadeados por um evento aleatório. Em meados dos anos 1960, Kahneman, que começava então sua carreira como professor de Universidade Hebraica, concordou em realizar um trabalho pouco emocionante: dar aulas a um grupo de instrutores de voo da Aeronáutica israelense sobre os pressupostos convencionais das mudanças de comportamento e suas aplicações à psicologia do treinamento de voo. Ele deixou claro de que a estratégia de recompensar comportamentos positivos funciona bem, ao contrário da de punir equívocos. Um de seus alunos o interrompeu, expressando uma opinião que acabaria por levar o cientista a uma epifania e por guiar suas pesquisas pelas décadas seguintes.

"Muitas vezes elogiei entusiasticamente meus alunos por manobras muito bem executadas, e na vez seguinte sempre se saíram pior", disse o instrutor de voo. "E já gritei com eles por manobras mal executadas, e geralmente melhoram na vez seguinte. Não venha me dizer que a recompensa funciona e a punição não. Minha experiência contradiz essa ideia." Os outros instrutores concordaram. Para Kahneman, a experiência deles parecia genuína. Por outro lado, ele acreditava nos experimentos com animais que demonstravam que a recompensa funcionava melhor que a punição. Ele meditou sobre esse aparente paradoxo. E então se deu conta: os gritos precediam a melhora, porém, ao contrário do que parecia, não a causavam.

Como era possível? A resposta se encontra num fenômeno chamado regressão à média. Isto é, em qualquer série de eventos aleatórios, há uma grande probabilidade de que um acontecimento extraordinário seja seguido, em virtude puramente do acaso, por um acontecimento mais corriqueiro. Funciona assim: cada aprendiz possui uma certa habilidade pessoal para pilotar jatos de caça. A melhora em seu nível de habilidade envolve diversos fatores e requer ampla prática; portanto, embora sue habilidade esteja melhorando lentamento ao longo do treinamento, a variação não será perceptível de uma manobra para a seguinte. Qualquer desempenho especialmente bom ou ruim será, em sua maior parte, uma questão de sorte. Assim, se um piloto fizer um pouso excepcionalmente bom, bem acima do seu nível normal de performance, haverá uma boa chance de que, no dia seguinte, essa performance se aproxime mais da norma - ou seja, piore. E se o instrutor tiver elogiado, ficará com a impressão de que o elogio não teve efeito positivo. Porém, se um piloto fizer um pouco excepcionalmente ruim - derrapar com o avião no fim da pista, entrando no tonel de sopa da lanchonete da base -, haverá uma boa chance de que, no dia seguinte, sua performance se aproxime mais da norma - ou seja, melhore. E se seu instrutor estiver o hábito de gritar "Seu jegue estabanado!", sempre que algum aluno tiver um desempenho ruim, ficará com a impressão de que a crítica teve efeito positivo. Dessa maneira surgiria um aparente padrão: aluno faz boa manobra, elogio tem efeito negativo; aluno faz manobra ruim, instrutor compara aluno a asinino em altos brados, aluno melhora. A partir de tais experiências, os instrutores concluíram que seus gritos constituíam uma eficaz ferramenta educacional. Na verdade, não faziam nenhuma diferença.

Referência

Mlodinow, Leonard. O Andar do Bêbado ISBN-13 9788537801550. 2009. p.15-16

Sim, você ouviu direito: Entropia no Software e a Teoria da Janela Quebrada. Pode parecer um pouco estranho no começo, talvez até esteja se perguntando "mas o que esses conceitos têm a ver com o mundo do software?". Esses dois conceitos não são termos comumente associados um ao outro, mas ao explorar mais a fundo, descobrimos que essas duas teorias podem oferecer uma perspectiva única sobre a gestão eficaz do desenvolvimento e manutenção de software. Neste artigo, exploramos como esses dois conceitos se inter-relacionam e como podem ser utilizados para melhorar as práticas de desenvolvimento de software.

Entropia

Parece um termo científico complicado, não é? Não se preocupe, juntos vamos desmistificar essa palavra e entender o que ela realmente significa, especialmente quando aplicada ao mundo do software. Pegue um café e vamos lá! ☕

Vamos começar no século XIX (19), com um cientista chamado Rudolf Clausius. Foi ele quem nos apresentou a entropia no mundo da termodinâmica. Mas como isso pode ser comparado ao desenvolvimento de software? Prometo que vamos chegar lá, mas antes vamos entender um pouco mais sobre o que Clausius queria dizer com entropia.

Entropia, no campo da física, é uma forma de medir a imprevisibilidade ou, como alguns preferem simplificar, a "desordem" dentro de um sistema. Agora, quando falo em "desordem", não quero dizer bagunça no sentido comum da palavra. Na verdade, estou falando sobre como a energia está distribuída em um sistema.

Imagine que temos uma caixa cheia de partículas. Se todas essas partículas estiverem concentradas em um único canto, podemos dizer que a entropia é baixa - há uma certa "ordem". Mas, se as partículas estão espalhadas de maneira aleatória por toda a caixa, aí temos uma alta entropia - a distribuição de energia é mais "imprevisível" ou "desordenada". A natureza tende ao estado de maior entropia, ou seja, as partículas irão se dispersar, a menos que algo externo intervenha. É como se a natureza gostasse de um pouco de imprevisibilidade

Agora, chegou a hora de conectar essa ideia com o mundo do software 🌉. Quando falamos em entropia no desenvolvimento de software, estamos nos referindo a essa tendência natural dos sistemas de software de se tornarem mais complexos e "desordenados" com o passar do tempo. E quando falo "desordem" aqui, estou falando de coisas como código mal estruturado, documentação insuficiente, bugs não corrigidos, code smells, e por aí vai.

O que acontece é que conforme o software cresce e evolui, é preciso esforço constante para evitar que essa entropia aumente. Precisamos trabalhar para manter o sistema organizado e eficiente - similar a como as partículas na caixa necessitam de uma força externa para não se espalharem aleatoriamente.

Agora que entendemos rapidamente o que é entropia, vamos entender alguns pontos que podem contribuir para o seu aumento dentro do software. Vou aproveitar essa parte para comentar algumas que, infelizmente, já presenciei também na indústria de software.

A falta de requisitos claros!

Vou compartilhar com você uma história que, apesar de fictícia, poderia facilmente se passar na realidade de muitas equipes de desenvolvimento de software. Prometo que é uma história com uma lição valiosa para todos nós: programadores, gerentes de projeto, product owners e qualquer um interessado em construir produtos de software de sucesso.

Pense em uma startup inovadora que está desenvolvendo um aplicativo de entrega de alimentos. Entre os muitos recursos desse aplicativo, surge um requisito especial: a opção de os usuários compartilharem um pedido com amigos, permitindo que todos adicionem seus itens preferidos à mesma ordem. Isso parece um diferencial competitivo incrível, não é mesmo?

No entanto, a descrição desse requisito é um pouco vaga e não entra em detalhes sobre como essa funcionalidade deve ser implementada. Deve existir um limite de usuários por pedido compartilhado? Como lidar com a divisão dos custos de entrega?

Nosso time de desenvolvimento, sempre buscando a eficiência, interpreta o requisito da melhor forma possível com as informações disponíveis. Eles decidem que não haverá limites para a quantidade de usuários em um pedido compartilhado, e que os custos de entrega serão divididos igualmente entre todos os participantes.

Quando o recurso é lançado, a reação dos usuários é mista. Alguns adoram a ideia, mas outros ficam frustrados. Eles não acham justo que um usuário que adicionou apenas um item pequeno pague a mesma taxa de entrega de alguém que pediu vários itens maiores. A falta de limites também causa problemas, com pedidos gigantescos causando atrasos nas entregas.

A lição aqui? Requisitos mal definidos podem levar a mal-entendidos, implementações imprecisas e até mesmo a um feedback negativo dos usuários.

Portanto, cada vez que um novo recurso é proposto, é fundamental não aceitarmos requisitos que pareçam insuficientemente detalhados ou que não estejam coerentes com a realidade. Esse é um dever compartilhado: a equipe de especialistas do domínio deve se esforçar para esclarecer as funcionalidades, enquanto os gestores de tecnologia precisam estar prontos para questionar e clarificar qualquer requisito que pareça vago.

E como isso afeta e colabora para a alta desordem do software?

Quando um recurso é implementado com base em requisitos mal definidos, pode levar a um código mal estruturado ou a uma arquitetura de software que não está alinhada com a verdadeira necessidade do negócio. Isso pode causar problemas, como dificuldades de manutenção, problemas de performance e até a introdução de bugs. Além disso, se os desenvolvedores precisam revisitar continuamente o recurso para corrigir mal-entendidos ou implementar mudanças, isso pode causar ainda mais complexidade e "desordem".

Isso gera estresse para a equipe. Afinal, provavelmente recursos que não foram planejados corretamente precisam de novas definições e modelagem de dados. Talvez novas tabelas precisem ser criadas, novos relacionamentos e entidades. Isso consequentemente pode gerar prazos de entregas irrealistas para correr atrás do prejuízo. Sabemos que muitas empresas deixam de lado em momentos críticos a qualidade, muitos recursos novos ou até os já existentes podem precisar de uma revisão completa, mas isso não é feito com qualidade. Percebe a cascata de problemas gerados? Isso é a desordem!

Portanto, requisitos mal definidos aumentam a entropia tanto no software quanto no negócio. Eles contribuem para um código mais caótico e complexo e podem levar a resultados de negócios indesejados. Ao mesmo tempo, lidar com esses requisitos e suas consequências demanda tempo e recursos, que poderiam ser usados para criar novos recursos ou melhorar outros aspectos do sistema. É por isso que é tão importante se esforçar para definir claramente os requisitos desde o início.

Má Comunicação entre equipes!

Vamos explorar um outro cenário bastante comum no mundo do desenvolvimento de software. Este é especialmente relevante se você já fez parte de uma equipe de desenvolvimento.

Vamos visualizar uma startup, trabalhando em um aplicativo de rede social. Temos dois times, temos um desenvolvedor encarregado de construir uma API que é o coração do sistema de notificação do aplicativo, responsável por alertar os usuários sobre novos likes, comentários e mensagens.

Por outro lado, temos outro programador, em outra equipe, cuja tarefa é desenvolver a interface de usuário (frontend) que exibirá essas notificações. Este desenvolvedor depende da API para receber esses dados e exibi-los de forma intuitiva e atraente para os usuários.

Agora, imagine que o desenvolvedor responsável pela API, na busca pela excelência, faz algumas melhorias significativas, otimizando a forma como os dados são entregues. No entanto, esquece-se de informar ao colega que depende dessa API sobre as mudanças realizadas, ou sobre a nova versão do serviço.

O programador frontend, completamente alheio à atualização, continua a trabalhar com a versão antiga da API. Quando o aplicativo é lançado, os usuários começam a reclamar que as notificações não estão funcionando como esperado, ou até mesmo aparecendo de forma errada.

A situação acima ilustra como um simples deslize na comunicação pode conduzir a um aumento na entropia do software. Essa disfunção não apenas introduz bugs, mas também pode causar frustração e confusão na equipe, e pior ainda, insatisfação no usuário final.

Portanto, a lição aqui é clara: a comunicação eficaz é fundamental para controlar a entropia no software. Manter todos na equipe informados sobre as mudanças e atualizações pode evitar equívocos e garantir que todos estejam alinhados, contribuindo para um software mais eficiente e um ambiente de trabalho mais harmônico.

E como a situação acima colabora para a alta desordem do software?

A situação descrita acima contribui significativamente para a alta entropia do software, ou desordem, de várias maneiras. Vamos dividi-la em pedaços para entender melhor.

1. Código Desatualizado ou Incompatível: O desenvolvedor que trabalha na interface do usuário está usando uma versão desatualizada da API. Isto pode levar a inconsistências no código, erros de compatibilidade e até mesmo falhas no sistema. Além disso, pode haver um impacto na performance do sistema.
2. Esforço Desnecessário: A equipe agora terá que gastar tempo extra corrigindo os problemas causados pela falta de comunicação. Isso significa tempo de desenvolvimento perdido que poderia ter sido usado para adicionar novos recursos ou melhorar outros aspectos do software.
3. Introdução de Bugs: A interface do usuário que depende da API desatualizada pode não funcionar como esperado, levando a bugs. Dependendo da gravidade desses bugs, eles podem afetar a experiência do usuário e até mesmo levar a perdas de dados.
4. Insatisfação do Usuário: A experiência do usuário pode ser prejudicada devido a funcionalidades mal implementadas ou bugs. Isso pode levar a feedback negativo, perda de usuários e danos à reputação do produto.

Esses fatores combinados aumentam a "desordem" ou entropia dentro do projeto de software. Eles criam uma situação onde a complexidade e a confusão dominam, dificultando a implementação de melhorias e correções. É por isso que a boa comunicação é tão crucial!

Mudanças frequentes nos requisitos!

Imagino que você já tenha se deparado com uma situação onde os requisitos para um software mudam constantemente, certo? Isso pode ser um grande desafio. Tais mudanças podem incluir novas funcionalidades, requisitos e processos que não foram considerados inicialmente. E o que isso causa? Aumento na complexidade do software, introdução de bugs e dificuldade para manter e evoluir o sistema.

Para ilustrar, vamos imaginar um programador desenvolvendo um software de gerenciamento de estoque. Durante o desenvolvimento, os requisitos estão em constante mudança: novos tipos de produtos são introduzidos, regras de desconto são alteradas e as informações dos produtos são variadas. Essa constante adaptação às mudanças pode resultar em uma arquitetura de software incerta e em constante fluxo.

Essa falta de estabilidade e clareza aumenta a entropia dentro do software. A fase de planejamento parece nunca chegar a uma conclusão definitiva, enquanto a lista de requisitos cresce e se transforma. A adição de caminhos de código desnecessários ou redundantes, em resposta a essas mudanças frequentes, pode levar a uma complexidade ainda maior, dificultando a compreensão do código e sua manutenção.

Além disso, com cada nova mudança, há um risco maior de introduzir bugs e falhas no software. Afinal, cada alteração requer uma revisão cuidadosa e testes completos para garantir que não está introduzindo novos problemas. Infelizmente, com prazos apertados e requisitos mal definidos, essa etapa crucial pode ser negligenciada, o que só aumenta a entropia do sistema.

Por fim, o que isso tudo tem a ver com o código que escrevemos? Bem, tudo! Quanto mais complexo o sistema se torna, mais difícil é para nós, desenvolvedores, entender e manter o código. Vamos conversar mais sobre esse assunto.

O código indesejado

A falta de diálogo entre as equipes, a falta de especificações claras e as mudanças frequentes nos requisitos podem impactar negativamente a forma como escrevemos código de várias maneiras:

Vamos começar com o Código inconsistente. Imagine uma equipe de desenvolvedores trabalhando em um projeto, mas com uma comunicação precária entre si. Isso pode resultar em diferentes interpretações dos requisitos e, portanto, inconsistências no código.

Agora, pense no Código mal mantido. Especificações nebulosas e mudanças constantes podem levar a um emaranhado de código "sujo", semelhante a um prédio mal conservado, que se torna cada vez mais difícil de manter.

Em seguida, temos os chamados "cheiros de código". Pense que está andando por uma rua e sente um odor desagradável. É um sinal de que algo não está limpo. No nosso código, os famosos code smells, são aspectos que sugerem problemas potenciais de qualidade ou design, geralmente provocados por mudanças frequentes nos requisitos ou até mesmo falta de experiencia dos programadores, falta de adoção de boas práticas entre outros fatores ligados a legibilidade do código.

Código redundante também é um problema. Sem especificações claras, podemos encontrar partes do código repetidas, aumentando a complexidade e o tempo de manutenção, principalmente pela falta de clareza e adoção do princípio DRY.

E quanto ao aumento de bugs? Isso pode ocorrer quando há falhas de comunicação e as especificações não são compreendidas corretamente. Mas principalmente ocorrem pela ausência de testes automatizados para validar os comportamentos que são esperados pelo software.

Como muitos lidam com esses problemas citados, quando se tornam insustentáveis?

Os desenvolvedores podem considerar refatorações significativas ou, em casos extremos, reescrever o software do zero. Mas atenção, essas são medidas de curto prazo. Se a equipe não adotar um plano consistente para controlar a entropia futura, a deterioração do código retornará. Mas o que tudo isso tem a ver com a teoria da janela quebrada?

A teoria da janela quebrada

No livro The Pragmatic Programmer, os autores argumentam que a entropia do software é contagiosa e, se não for controlada, torna-se uma epidemia. Além disso, fazem uma analogia com a teoria da janela quebrada. Vamos estudar isso mais afundo.

Proposta pelos criminologistas James Wilson e George Kelling e tendo um enorme impacto na política policial durante a década de 1990, a teoria das janelas quebradas é uma ideia que sugere que a desordem física em um ambiente urbano, como pichações e vidraças quebradas, pode levar a um aumento da criminalidade naquela área ou degradação por vândalos no local.

Bom, você deve estar se perguntando, "Mas o que isso tem a ver com a entropia em software?" A resposta é: muito mais do que você imagina!

Considere um código com inconsistências, redundâncias, bugs ou mesmo code smells. Cada um desses elementos pode ser visto como uma "janela quebrada" na engenharia de software. Deixá-los sem solução, ou pior, permitir que se acumulem, gera uma crescente desordem - ou seja, a entropia do software. Essa alta entropia faz com que o código se torne cada vez mais difícil de manter, entender e evoluir.

De maneira similar à Teoria da Janela Quebrada, um código mal cuidado e desorganizado pode incentivar práticas ruins de programação. Imagine que um novo membro da equipe se depara com um código repleto de inconsistências e bugs. Se não houver um esforço consciente para manter a qualidade do código, esse novo membro pode ser levado a pensar: "Se o código já está nesse estado, por que eu deveria me esforçar para escrever um código de qualidade?".

A consequência é um ciclo vicioso, onde a qualidade do software se deteriora, a produtividade diminui, os bugs aumentam e a entropia se torna incontrolável. Assim como em uma casa de bairro onde as janelas quebradas não são consertadas, a desordem acaba por tomar conta.

Podemos acrescentar ainda mais, códigos confusos sem documentação e testes inadequados podem indicar aos desenvolvedores e gerentes de projeto que a qualidade não é uma prioridade, levando a comportamentos e decisões inadequadas para o contexto. Isso pode incluir a adição de novos recursos sem levar em conta a manutenção, omitir refatorações necessárias e não monitorar a qualidade do código. Esses comportamentos inadequados podem levar a um efeito dominó de problemas, onde a entropia do código aumenta gradualmente.

A relação entre a Teoria da Janela Quebrada e a entropia é esta: ambos são formas de entender a importância da manutenção contínua e do cuidado com os detalhes. Tanto em uma cidade quanto em um sistema de software, a desordem se instala quando permitimos que pequenos problemas se acumulem. E a maneira de combater isso é através do cuidado constante, da manutenção regular e da atenção aos detalhes.

Como tratar esse problema grave?

A primeira coisa a se ter em mente é que qualidade e manutenção não são aspectos a serem considerados apenas no final de um projeto - eles devem estar presentes desde o início. Pare de pensar que testes e refatorações são perdas de tempo!

Segundo, mantenha a comunicação. Parece simples, mas é crucial. É necessário que todos os membros da equipe, sejam desenvolvedores, gerentes, proprietários de produtos ou outras partes interessadas, estejam alinhados em termos de requisitos, prazos e objetivos. Dessa forma, podemos reduzir mal-entendidos e evitar inconsistências que contribuem para a entropia.

Terceiro, ter uma política de código limpo e seguir as melhores práticas de codificação. Aqui entram padrões de codificação consistentes, revisões de código, testes automatizados e uma atitude proativa em relação à refatoração. Não se trata apenas de escrever código que funciona, mas de escrever código que outros possam entender e manter.

Quarto, devemos prestar atenção à arquitetura do nosso software. Uma arquitetura bem planejada e escalável reduz a probabilidade de termos que realizar mudanças drásticas no futuro, que podem introduzir novos bugs e aumentar a complexidade e a entropia. Uma arquitetura planejada de maneira precipitada leva a complexidade desnecessária e a um conflitos de ideias entre desenvolvedores dentro do projeto.

Por fim, a gestão eficaz das mudanças. Mudanças são inevitáveis em qualquer projeto, mas a maneira como lidamos com elas pode fazer uma grande diferença. Uma abordagem ágil, que encoraja o feedback contínuo e a adaptação, pode ajudar a gerir as mudanças de uma forma que reduza a entropia ao invés de aumentá-la.

Cada janela quebrada que consertamos é um passo na direção certa. Cada bug corrigido, cada inconsistência eliminada, cada "cheiro de código" resolvido contribui para o controle da entropia. E, ao manter a entropia sob controle, garantimos que nosso software seja sustentável, escalável, testável, compreendido e, acima de tudo, um fácil de modificar e trabalhar.

Como os testes ajudam a manter a entropia sobre controle?

Os testes continuam sendo uma ferramenta subestimada por muitos desenvolvedores na luta contra a alta entropia no software. Por que? Já tentou montar um quebra-cabeças sem a imagem de referência? Bem, se você já o fez, sabe o quão complicado é montar a imagem. Testes, meus caros leitores, são como essa imagem de referência na construção do nosso grande quebra-cabeças de software. Sem uma imagem clara do sistema, não podemos saber exatamente o que um software faz, ou seja, seu propósito. Seus principais recursos e objetivos. Testes refletem os comportamentos do software, são um espelho do software, que podemos executar e entender pelo que cada pedaço de código é responsável!

Os testes de software, unitários, de integração, funcional, de stress, entre outros, têm um papel crucial na prevenção e controle da entropia do software. Como exatamente?

1. Detectando problemas mais cedo: Testes bem escritos ajudam a identificar bugs, inconsistências e falhas mais cedo, quando eles são mais fáceis (e mais baratos) de serem corrigidos. Testes automatizados executados regularmente garantem que qualquer "janela quebrada" seja prontamente detectada, evitando a propagação da entropia.
2. Prevenindo a regressão: À medida que o software evolui, é fácil quebrar funcionalidades existentes sem perceber. Com uma suíte de testes abrangente, você tem uma rede de segurança que ajuda a prevenir esses problemas, garantindo que o software continue funcionando como esperado após cada mudança.
3. Documentação viva: Testes são uma espécie de documentação viva do sistema, que descreve como ele deve funcionar. Ao consultar os testes, novos membros da equipe ou mesmo desenvolvedores veteranos podem entender melhor o código, mantendo a base de código consistente e minimizando a entropia.
4. Melhora a qualidade do código: Testes incentivam os desenvolvedores a escreverem códigos mais modulares e independentes (fáceis de testar), o que por si só já contribui para reduzir a entropia.
5. Fornece confiança para refatorar : Melhorar seu design sem alterar seu comportamento é uma atividade necessária para manter a entropia controlada. Testes fornecem a segurança de que, se algo quebrar durante a refatoração, será prontamente detectado.

No livro que estou escrevendo que pretendo anunciar o nome em breve, falo sobre esses pontos de uma perspectiva mais prática para a indústria de software. Realmente quando levamos muito a sério os testes, temos ganhos significativos de produtividade no dia a dia ao programar novos recursos e manter os que já existem. Obviamente não é uma tarefa simples, existem desafios e principalmente compromisso com a qualidade.

Em conclusão, a Teoria da Janela Quebrada nos ensina que a tolerância a pequenas falhas ou "janelas quebradas" no nosso código pode levar a uma cascata de problemas. Os desenvolvedores podem começar a achar que é aceitável produzir código de baixa qualidade, ou ignorar os testes, aumentando assim a entropia. Ao abraçar boas práticas e manter um olhar atento para "janelas quebradas", podemos manter a entropia sob controle e assegurar que nossos projetos de software permaneçam saudáveis e sustentáveis.

Novamente, é mais fácil escrever do que colocar em prática, por isso estou centralizando em um livro esse tema para abordar com mais liberdade e profundidade esse assunto tão complexo e interessante que faz parte do nosso cotidiano.

Fico por aqui. Espero que tenham gostado! Muito obrigada pela leitura até o final, espero que as dicas possam ajudar no dia a dia! Até o próximo artigo! 😄🖐️

O Linux divide sua RAM física (memória de acesso aleatório) em pedaços de memória chamados páginas. Swapping, ou troca, é o processo pelo qual uma página de memória é copiada para o espaço pré-configurado no disco rígido, chamado espaço swap ou espaço de troca ou swap space, para liberar essa página de memória. Os tamanhos combinados da memória física e do espaço swap são a quantidade de memória virtual disponível.

Os usuários podem criar um espaço swap durante a instalação ou em qualquer momento posterior, conforme desejado. O espaço swap pode ser usado para duas finalidades, estender a memória virtual além da memória física instalada (RAM), também conhecido como "ativar swap", e também para suporte de suspensão para disco.

Veja esse artigo no Arch Wiki para informações mais detalhadas.

How To

O btrf só comessou a suportar a utilização de swap files apartir do kernel 5.0.0, e exige alguns comandos extras:

Primeiro vamos criar um diretório "non-snapshotted" na raiz do sistema, onde estará nossos swap files

sudo btrfs subvolume create /swap

Agora vamos criar o swap file em si, com o comando próprio do btrfs, já passando o tamanho que queremos alocar:

sudo btrfs filesystem mkswapfile --size 10g --uuid clear /swap/swapfile

note em que estou criando um arquivo de 10 gigabytes em 10g, mas você pode passar o tamanho que quiser. Se --size for omitido, será criado um arquivo de 2GiB por padrão.

Depois de criado, vamos ativar o swap file com o comando padrão swapon:

sudo swapon /swap/swapfile

Para vermos se o swap que criamos está ativado. basta rodar o comando:

sudo swapon --show

Com o swap file criado e ativado, basta adicionarmos a configuração no arquivo fstab para que o sistema use-o automaticamente quado reiniciar:

/swap/swapfile none swap defaults 0 0

Referências

How to Create a Linux Swap File: https://phoenixnap.com/kb/linux-swap-file [archive]

Create a Linux Swap File: https://linuxize.com/post/create-a-linux-swap-file/ [archive]

Swap file vs swap partition ? when to use what ? any disadvantages or advantage …: https://kodekloud.com/community/t/swap-file-vs-swap-partition-when-to-use-what-any-disadvantages-or-advantage/146383 [archive]

Btrfs - ArchWiki: https://wiki.archlinux.org/title/Btrfs#Swap_file [archive]

btrfs(5) - Arch manual pages: https://man.archlinux.org/man/btrfs.5#SWAPFILE_SUPPORT [archive]

Swap (Português): https://wiki.archlinux.org/title/Swap_(Portugu%C3%AAs) [archive]

Esta é uma tradução da postagem original Colocation de Kent C. Dodds.

Todos nós queremos ter bases de código fáceis de manter, então começamos com a melhor das intenções para tornar nossa base de código (ou nosso canto da base de código) sustentável e fácil de entender. Com o tempo, à medida que uma base de código cresce, pode se tornar cada vez mais difícil gerenciar dependências (JS, CSS, imagens, etc.). À medida que os projetos crescem, uma quantidade crescente de sua base de código se torna "conhecimento tribal" (conhecimento do qual apenas você ou alguns outros têm acesso) e esse tipo de conhecimento contribui para a "dívida técnica" (seja esse termo preciso ou não).

Eu gosto de manter minhas bases de código gerenciáveis não apenas para mim (aquele que o escreveu), mas também para meus colegas de equipe, futuros mantenedores e para mim mesmo em 6 meses. Acho que todos podemos concordar que esse é um grande ideal pelo qual devemos nos esforçar em nossas bases de código. Existem muitas ferramentas e técnicas diferentes à nossa disposição para realizar isso.

Vamos falar sobre comentários de código

Não quero discutir se deve comentar seu código (você deveria) e sobre o que seus comentários devem ser (você explica por que está fazendo algo inesperado nos comentários para que as pessoas que vêm depois possam entender as decisões que foram tomadas que resultaram em o código inesperado ou estranho). (Ok, talvez eu queira falar um pouco sobre isso). Em vez disso, quero me concentrar em onde esses comentários de código são colocados. Geralmente "co-localizamos" esses comentários com o código que eles estão explicando, colocando-os o mais próximo possível do código relevante.

Considere por um minuto, se fizéssemos isso de forma diferente. E se colocarmos esses comentários em um arquivo totalmente separado. Um enorme arquivo DOCUMENTATION.md ou talvez até mesmo um diretório docs/ que mapeia de volta para o nosso diretório src/. Parece divertido para você? Sim, para mim também não. Haveria alguns problemas sérios que encontraríamos ao não co-localizar nossos comentários com o código que está explicando.

• Manutenibilidade: eles ficariam fora de sincronia ou desatualizados mais rapidamente (do que já estão). Moveríamos ou excluiríamos um arquivo src/ sem atualizar o arquivo docs/ correspondente.
• Aplicabilidade: as pessoas que olham para o código em src/ podem perder um comentário importante em docs/ ou não comentar seu próprio código porque não percebem que existe um arquivo docs/ para o arquivo src/ que estão editando.
• Facilidade de uso: a troca de contexto de um local para outro também seria um desafio com esse tipo de configuração. Ter que lidar com vários locais para arquivos pode tornar difícil garantir que você tenha tudo o que precisa para manter um componente.

Definitivamente, poderíamos criar uma convenção para esse tipo de estilo de comentário de código, mas por que iríamos querer? Não é mais simples manter os comentários co-localizados com o código que estão explicando?

E daí?

Agora, você provavelmente está pensando consigo mesmo: "Sim, claro, é por isso que ninguém faz essa coisa de docs/ e todo mundo apenas co-localiza seus comentários com o código. Isso é óbvio. Qual é o seu ponto?" Meu ponto é que os benefícios da co-localização estão em toda parte.

HTML/Visualização

Tome HTML, por exemplo. Todos os benefícios de co-localizar nossos comentários também se traduzem em nossos modelos. Antes de estruturas modernas como o React, você teria sua lógica de visualização e seus modelos de visualização em diretórios totalmente separados. Isso é vítima dos mesmos problemas descritos acima. Hoje em dia é muito mais comum colocar essas coisas exatamente no mesmo arquivo com React e Vue, por exemplo. Com Angular, se não estiver no mesmo arquivo, o arquivo de modelo está pelo menos próximo ao arquivo JS ao qual está associado.

CSS

Outro conceito ao qual isso se aplica bem é o CSS. Não vou discutir com você sobre os méritos do CSS-in-JS (é fantástico), mas os benefícios são de outro mundo. Saiba mais aqui.

Testes

Esse conceito de co-localização de arquivos também se aplica muito bem a testes de unidade. Quão comum é encontrar um projeto com um diretório src/ e um diretório test/ preenchido com testes de unidade que tentam espelhar o diretório src/? Todas as armadilhas descritas acima também se aplicam aqui. Eu provavelmente não iria tão longe a ponto de colocar os testes de unidade exatamente no mesmo arquivo, mas também não descarto totalmente isso como uma ideia interessante (a implementação é deixada como um exercício para o leitor).

Para ajudar a permitir uma base de código mais sustentável, devemos co-localizar nossos arquivos de teste com o arquivo ou grupo de arquivos que estão testando. Isso garante que, quando novas pessoas (ou eu mesmo em 6 meses) chegarem ao código, elas possam ver imediatamente que o módulo foi testado e usar esses testes como referência para aprender sobre o módulo. Quando eles fazem alterações, ele os lembra de atualizar (adicionar/remover/modificar) os testes para contabilizar suas alterações.

Estado

O estado do aplicativo/componente apresenta os mesmos benefícios. Quanto mais desconectado/indireto for seu estado da IU que o está usando, mais difícil será mantê-lo. A localização do estado tem ainda mais benefícios do que a capacidade de manutenção, mas também melhora o desempenho do seu aplicativo. Uma alteração de estado em um canto da árvore de componentes do aplicativo renderizará muito menos componentes do que uma alteração de estado no topo da árvore. Localize seu estado.

Arquivos utilitários "reutilizáveis"

Isso também se aplica a arquivos e funções "utilitárias". Imagine que você está escrevendo um componente e vê um bom pedaço de código que pode ser extraído em sua própria função. Você extrai e pensa: "Ah... aposto que muita gente poderia usar isso." Então você o retira e coloca no diretório utils/ do seu aplicativo e segue em frente com sua vida.

Posteriormente, seu componente é excluído, mas o utilitário que você escreveu está fora de vista, fora da mente e permanece (junto com seus testes) porque a pessoa que o excluiu presumiu que era mais usado. Ao longo dos anos, os engenheiros trabalharam duro para garantir que a função e seus testes continuem a funcionar corretamente, mesmo sem perceber que não são mais necessários. Esforço desperdiçado e carga cognitiva.

Se, em vez disso, você tivesse deixado essa função diretamente no arquivo que a utilizou, a história seria completamente diferente. Não estou dizendo para não se incomodar com o teste de unidade de funções utilitárias complexas (por favor, faça), mas mantê-las mais perto de onde são necessárias ajuda a evitar problemas.

O princípio

O conceito de co-localizaçao pode ser resumido a este princípio fundamental:

Você também pode dizer: "As coisas que mudam juntas devem ser localizadas o mais próximo possível." (Dan Abramov disse algo assim para mim uma vez).

Código aberto facilita

Além de evitar os problemas discutidos anteriormente, há outros benefícios em estruturar seus projetos dessa maneira. Pegar um componente e transformá-lo em um projeto de código aberto geralmente é tão simples quanto copiar/colar a pasta para outro projeto e publicá-lo no npm. Em seguida, basta instalá-lo em seu projeto e atualizar suas instruções de require/import e pronto.

Exceções

Claro que há um bom argumento para a documentação que abrange todo ou parte de um sistema e como as coisas se integram. E onde você colocaria a integração ou os testes de ponta a ponta que abrangem os componentes? Você pode pensar que essas são exceções, mas na verdade elas podem se encaixar perfeitamente no princípio mencionado acima

Se eu tiver uma parte do meu aplicativo associada à autenticação do usuário e quiser documentar esse fluxo, posso colocar um arquivo README.md na pasta que contém todos os módulos associados à autenticação do usuário. Se eu precisar escrever testes de integração para esse fluxo, posso colocar o arquivo desses testes na mesma pasta.

Para testes de ponta a ponta, geralmente faz mais sentido ir na raiz do projeto. Eles vão além do próprio projeto e em outras partes do sistema, então faz sentido para mim que estejam em um diretório separado. Eles realmente não mapeiam para os arquivos src/. Na verdade, os testes E2E realmente não se importam com a forma como o src/ está organizado. A refatoração e a movimentação de arquivos no diretório src/ não devem exigir a alteração dos testes E2E.

Conclusão

Nosso objetivo aqui é construir um software que seja o mais simples possível de manter. Os mesmos benefícios de manutenibilidade, aplicabilidade e facilidade de uso que obtemos com a colocalização de nossos comentários, também obtemos com a colocalização de outras coisas. Se você nunca experimentou, recomendo que experimente.

P.S. Se você está preocupado em violar a "separação de preocupações", recomendo que verifique esta palestra de Pete Hunt e reavalie o que isso significa 😀.

P.P.S. Também devo observar que isso se aplica muito bem a imagens e a qualquer outro recurso também. E quando você usa uma ferramenta como o webpack, co-localizar esses recursos também é muito fácil. Honestamente, esta é uma das principais propostas de valor do webpack IMO.

Colonel/Rose A.I speech - Raiden | Metal Gear Solid 2

Transcript

Colonel:
To begin with -- we're not what you'd call -- human.Over the past two hundred years -- A kind of consciousness formed layer by layer in the crucible of the White House.It's not unlike the way life started in the oceans four billion years ago.The White House was our primordial soup, a base of evolution -- We are formless.We are the very discipline and morality that Americans invoke so often.How can anyone hope to eliminate us?As long as this nation exists, so will we.

Raiden:
Cut the crap! If you're immortal, why would you take away individual freedoms and censor the Net?

Rose:
Jack, don't be silly.

Colonel:
Don't you know that our plans have your interests -- not ours -- in mind?

Raiden:
What?

Rose:
Jack, listen carefully like a good boy!

Colonel:
The mapping of the human genome was completed early this century.
As a result, the evolutionary log of the human race lay open to us.

Rose:
We started with genetic engineering, and in the end, we succeeded in digitizing life itself.

Colonel:
But there are things not covered by genetic information.

Raiden:
What do you mean?

Colonel:
Human memories, ideas.
Culture.
History.

Rose:
Genes don't contain any record of human history.

Colonel:
Is it something that should not be passed on?
Should that information be left at the mercy of nature?

Rose:
We've always kept records of our lives.
Through words, pictures, symbols...
from tablets to books...

Colonel:
But not all the information was inherited by later generations.
A small percentage of the whole was selected and processed, then passed on.
Not unlike genes, really.

Rose:
That's what history is, Jack.

Colonel:
But in the current, digitized world, trivial information is accumulating every second, preserved in all its triteness.
Never fading, always accessible.

Rose:
Rumors about petty issues, misinterpretations, slander...

Colonel:
All this junk data preserved in an unfiltered state, growing at an alarming rate.

Rose:
It will only slow down social progress, reduce the rate of evolution.

Colonel:
Raiden, you seem to think that our plan is one of censorship.

Raiden:
Are you telling me it's not!?

Rose:
You're being silly! What we propose to do is not to control content, but to create context.

Raiden:
Create context?

Colonel:
The digital society furthers human flaws and selectively rewards the development of convenient half-truths.
Just look at the strange juxtapositions of morality around you.

Rose:
Billions spent on new weapons in order to humanely murder other humans.

Colonel:
Rights of criminals are given more respect than the privacy of their victims.

Rose:
Although there are people suffering in poverty, huge donations are made to protect endangered species.
Everyone grows up being told the same thing.

Colonel:
"Be nice to other people."

Rose:
"But beat out the competition!"

Colonel:
"You're special."
"Believe in yourself and you will succeed."

Rose:
But it's obvious from the start that only a few can succeed...

Colonel:
You exercise your right to "freedom" and this is the result.
All rhetoric to avoid conflict and protect each other from hurt.
The untested truths spun by different interests continue to churn and accumulate in the sandbox of political correctness and value systems.

Rose:
Everyone withdraws into their own small gated community, afraid of a larger forum.
They stay inside their little ponds, leaking whatever "truth" suits them into the growing cesspool of society at large.

Colonel:
The different cardinal truths neither clash nor mesh.
No one is invalidated, but nobody is right.

Rose:
Not even natural selection can take place here.
The world is being engulfed in "truth".

Colonel:
And this is the way the world ends.
Not with a bang, but a whimper.

Rose:
We're trying to stop that from happening.

Colonel:
It's our responsibility as rulers.
Just as in genetics, unnecessary information and memory must be filtered out to stimulate the evolution of the species.

Raiden:
And you think you're qualified to decide what's necessary and not?

Colonel:
Absolutely.
Who else could wade through the sea of garbage you people produce, retrieve valuable truths and even interpret their meaning for later generations?

Rose:
That's what it means to create context.

Raiden:
I'll decide for myself what to believe and what to pass on!

Colonel:
But is that even your own idea?

Rose:
Or something Snake told you?

Colonel:
That's the proof of your incompetence, right there.
You lack the qualifications to exercise free will.

Raiden:
That's not true! I have the right --

Rose:
Does something like a "self" exist inside of you?

Colonel:
That which you call "self" serves as nothing more than a mask to cover your own being.

Rose:
In this era of ready-made 'truths', "self" is just something used to preserve those positive emotions that you occasionally feel...

Colonel:
Another possibility is that "self" is a concept you conveniently borrowed under the logic that it would endow you with some sense of strength...

Raiden:
That's crap!

Colonel:
Is it?
Would you prefer that someone else tell you?
Alright then.
Explain it to him.

Rose:
Jack, you're simply the best! And you got there all by yourself!

Raiden:
Grrr...

Colonel:
Oh, what happened?
Do you feel lost?
Why not try a bit of soul-searching?

Rose:
Don't think you'll find anything, though...

Colonel:
Ironic that although "self" is something that you yourself fashioned, every time something goes wrong, you turn around and place the blame on something else.

Rose:
"It's not my fault. It's not your fault."

Colonel:
In denial, you simply resort to looking for another, more convenient "truth" in order to make yourself feel better.

Rose:
Leaving behind in an instant the so-called "truth" you once embraced.

Colonel:
Should someone like that be able to decide what is "truth"?

Rose:
Should someone like you even have the right to decide?

Colonel:
You've done nothing but abuse your freedom.

Rose:
You don't deserve to be free!

Colonel:
We're not the ones smothering the world.
You are.

Rose:
The individual is supposed to be weak.
But far from powerless -- a single person has the potential to ruin the world.

Colonel:
And the age of digitized communication has given even more power to the individual.
Too much power for an immature species.

Rose:
Building a legacy involves figuring out what is wanted, and what needs to be done for that goal.
All this, you used to struggle with.
Now, we think for you.

Colonel:
We are your guardians after all.

Raiden:
You want to control human thought?
Human behavior?

Colonel:
Of course.
Anything can be quantified nowadays.
That's what this exercise was designed to prove.

Rose:
You fell in love with me just as you were meant to, after all.
Isn't that right, Jack?

Colonel:
Ocelot was not told the whole truth, to say the least.

Rose:
We rule an entire nation -- of what interest would a single soldier, no matter how able, be to us?

Colonel:
The S3 Plan does not stand for Solid Snake Simulation.
What it does stand for is Selection for Societal Sanity...

Video

Refs

MGS2 Colonel A.I speech: https://www.reddit.com/r/copypasta/comments/9l5ri2/mgs2_colonel_ai_speech/ [Archive]

Referências

Prefixos do SI e suas diversas significações: https://www.facebook.com/PROFCADOSORIO/posts/2336808976461448

Esse é um resumo do vídeo “Leandro Karnal fala sobre ética em ambientes profissionais”, uma entrevista do canal Tribunal Superior do Trabalho ao filósofo Leandro Karnal. O resumo foi realizado para o cumprimento de uma atividade do curso de Logística, da instituição SENAI, e decidi registra-la aqui.

Ética no ambiente de trabalho

Primeiramente, oque é a Ética? Ética é o estudo de valores que permitem a convivência harmônica, a busca entre o bom e o belo, a busca da vida politica. Ela rege a capacidade que temos de estabelecer sociabilidade, sociedade, relações, sem a destruição do outro, sem a invasão do espaço do outro, e sem a imposição dos meus valores sobre o outro. Toda ética se baseia no respeito ao espaço do outro, o primeiro passo da ética nos chamamos pequena ética, etiqueta, que se refere a convivência cotidiana com o espaço o outro. Depois a compreensão no ambiente de trabalho, que a hierarquia existe, e que cada um tem suas funções, suas delimitações, e independente da minha posição no organograma do poder, todos são iguais perante a lei e capazes do exercício da convivência.

O ambiente profissional é o ambiente mais claro, onde as pessoas estão sem ter a mesma intimidade familiar, e o mesmo distanciamento da política. É no ambiente de trabalho que exercemos algo acima da afetividade da família, e abaixo do grande distanciamento da política, o grande exercício da ética é no ambiente de trabalho. Já que nos temos a convivência da diversidade, por exemplo, a diversidade de
gêneros, a diversidade de formações, a diversidade de origens sociais, a primeira questão é a do respeito. Então quando utilizo o meu poder ou minha função para exercer algum tipo de invasão do espaço alheio, eu estou quebrando essa ética, ou seja, devemos entender que o ambiente de trabalho não tem a intimidade da família, logo, eu não posso tratar as pessoas como se fossem íntimos familiares. Entender que a diferença entre gênero e hierarquia, são diferenças de serviço. Devemos seguir a regra de ouro da moral e das religiões, “Fazer ao outro o que você quer que faça a você mesmo”.

A todo estante devemos fazer uma reflexão sobre como estamos exercendo a ética, a ética só existe se ela for cultivada como uma capacidade de aperfeiçoamento. Todos nascemos sem ética, todos podemos aprimora-la, por isso é necessário um código de ética, é necessário a atividade do debate, e é necessário a atividade da avaliação da ética. Temos que produzir a sensibilidade ética, que é a sensibilidade ao outro, que fará uma negociação positiva entre o meu bem, e o bem alheio, para a produção do bem comum. A ética rege esses três polos: o eu, o tu, e o nós, e o nós só exste através
do debate, da melhoria e da crítica permanente.

Temos que entender que pode haver demanda, pedido de trabalho, mas que ele nunca passará pela sedução, ou, pelo exercício de poder, que ignore a especificidade da outra pessoa. Devemos pensar em um cargo como um estado momentâneo, ou seja, “eu ESTOU coordenadora”, “eu ESTOU chefe”, “eu ESTOU presidente”, isso significa que temos que lembrar que servimos a outras pessoas, é um exercício de estar, e não de ser, como já citado: “eu ESTOU chefe”, e não “eu SOU chefe”.

Para melhorar o ambiente de trabalho e torna-lo mais saudável e ético devemos, primeiro, criar eventos e trazer debates, entrevistas e questões. Temos que refletir sobre o código de ética atual, temos que demonstrar que o ser humano pode ser aperfeiçoado, que tudo que for próprio do ser humano pode ser transformado e melhorado. É do exercício humano, perfectível, aperfeiçoável, que podemos constantemente produzir algo melhor, por isso, que nos temos pessoas mais éticas, e pessoas menos éticas, porque ética é um esforço pessoal de cultivo diário. Não basta só dizer “agora o tribunal é ético porque tem um código”, é preciso um exercício, constante, diário, cotidiano, e uma meta a ser atingida. Nunca seremos integralmente éticos, mas nos podemos melhorar a partir do ponto que estamos.

Referências

Leandro Karnal fala sobre ética em ambientes profissionais: https://www.youtube.com/watch?v=pEXhGE7Fd6s

O GPG

O GPG é um programa de linha de comando que possibilita encriptar mensagens e arquivos usando um sistema de chaves assimétricas. Segundo o site do próprio GPG:

GnuPG is a complete and free implementation of the OpenPGP standard as defined by RFC4880 (also known asPGP). GnuPG allows you to encrypt and sign your data and communications; it features a versatile key management system, along with access modules for all kinds of public key directories. GnuPG, also known asGPG, is a command line tool with features for easy integration with other applications.

Para entender a diferença de PGP e GPG, veja esse artigo.

O GPG usa um sistema de chave publica/privada, que possibilita encriptar mensagens e arquivos, e assinar os mesmos.

Criptografia assimétrica x simétrica

Na criptografia simétrica, a chave que usamos para criptografar é a mesma usada para descriptografar. O problema disso, é que a chave precisa ser passada para o destinatário da mensagem criptografada, oque corre o risco de ser interceptada, se tornando inútil a criptografia, visto que o interceptador tem acesso tanto a mensagem quanto a chave que vai descriptografa-la.

Na criptografia assimétrica, a chave que usamos para criptografar será diferente da que usamos para criptografar. Neste caso o destinatário só terá que enviar sua chave pública para o remetente criptografar a mensagem usando a mesma, esta mensagem só poderá ser descriptografada usando a chave privada do destinatário, chave essa que não será enviada na transação, não correndo o risco de ser interceptada.

Ambiente

• OS: Parrot OS 4.11 x86_64
• Kernel: 5.10.0-8parrot1-amd64
• Shell: ZSH 5.8
• gpg (GnuPG): 2.2.27

Instalação

O GnuPG pode ser baixado nesta página: https://gnupg.org/download/index.html

No caso de sistemas baseados em Debian, que usa o gerenciador de pacotes APT, é só rodar o seguinte comando no terminal:

$ sudo apt install gnupg

Existe também uma lista de front-ends do gpg com interface gráfica no site do GnuPG: https://www.gnupg.org/software/frontends.html

Criptografia Simétrica

O foco da criptografia PGP, é a criptografia assimétrica, mas o GnuPG também tem a opção de criptografar algo usando apenas a criptografia assimétrica.

Encrypt

Primeiro vamos criar um arquivo chamado mensagem.txt, com a mensagem "Mensagem super secreta". Nós queremos proteger essa mensagem, para que ninguém que possua a chave possa ter acesso a esta mensagem. Para criptografar a mensagem basta usar a opção --symmetric e o nome do arquivo:

$ gpg --symmetric mensagem.txt

O software pedirá para que você digite a senha a ser usada, neste caso estou usando a senha 123456.

Note que foi criado um arquivo com a extensão .gpg (mensagem.txt.gpg), esse arquivo é o arquivo criptografado, agora é só deletar o arquivo original, e ficar apenas com o arquivo criptografado.

Decrypt

Para descriptografar a mensagem, usamos o seguinte comando:

$ pgp --output mensagem.txt --decrypt mensagem.txt.gpg

Opções:

• --output [arquivo]: Define o arquivo de saída a partir do arquivo criptografado.
• --decrypt [arquivo]: Define o arquivo a ser descriptografado.

Criptografia Assimétrica

Como já citado, a criptografia assimétrica usa um conceito de chave pública-privada, então para usarmos essa categoria de criptografia precisamos primeiro criar nosso par de chaves (key-pair).

Criar o key-pair

Para criar o key-pair basta passar a opção --full-generate-key, sem nenhum outro argumento, o gpg fará uma série de perguntas:

1. O tipo de criptografia a ser usada na hora de gerar as chaves.
2. O tamanho da chave. Quanto maior a chave mais seguro, mas creio que o padrão recomendado pelo gpg (3072) é o suficiente.
3. Tempo de duração até a chave expirar. Você tem a opção de expirar a chave em alguns dias, semana, meses, ou anos, ou até sem nenhuma data de expiração. Ai vai da utilidade que terá essa chave.
4. Ele pede seu nome, email e um comentário, para poder facilitar na identificação do dono da chave. O gpg não verifica a validade de nome e email, então não ha problema em usar informações fictícias. O comentário é exibido ao lado do nome, e pode ser usado para informar um apelido (nickname), ou uma informação adicional sua, ou até pode-se deixar em branco.
5. Logo após, aparecera uma janela para criar a senha principal da sua chave privada. Escolha uma senha forte.

$ gpg  --full-generate-key

gpg (GnuPG) 2.2.27; Copyright (C) 2021 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Por favor selecione o tipo de chave desejado:
    (1) RSA and RSA (default)
    (2) DSA and Elgamal
    (3) DSA (apenas assinatura)
    (4) RSA (apenas assinatura)
    (14) Existing key from card
Opção? 1

RSA keys may be between 1024 and 4096 bits long.
What keysize do you want? (3072)
O tamanho de chave pedido é 3072 bits

Por favor especifique por quanto tempo a chave deve ser válida.
    0 = chave não expira
    <n> = chave expira em n dias
    <n>w = chave expira em n semanas
    <n>m = chave expira em n meses
    <n>y = chave expira em n anos
A chave é valida por? (0) 1
Key expires at sáb 04 set 2021 12:20:51 -03
Is this correct? (y/N) y

GnuPG needs to construct a user ID to identify your key.

Nome completo: Oh tal doh Mattewz
Endereço de correio eletrónico: mateusfg7@email.eu
Comentário: mateusfg7
Você selecionou este identificador de utilizador:
"Oh tal doh Mattewz (mateusfg7) <mateusfg7@email.eu>"

Mudar (N)ome, (C)omentário, (E)ndereço ou (O)k/(S)air? O

Precisamos gerar muitos bytes aleatórios. É uma boa ideia realizar outra
actividade (escrever no teclado, mover o rato, usar os discos) durante a
geração dos números primos; isso dá ao gerador de números aleatórios
uma hipótese maior de ganhar entropia suficiente.
Precisamos gerar muitos bytes aleatórios. É uma boa ideia realizar outra
actividade (escrever no teclado, mover o rato, usar os discos) durante a
geração dos números primos; isso dá ao gerador de números aleatórios
uma hipótese maior de ganhar entropia suficiente.

gpg: key 0DA9480F7387D94C marked as ultimately trusted
gpg: revocation certificate stored as '/home/mateusfg7/.gnupg/openpgp-revocs.d/D3EED251C38AE4F4F3EE39310DA9480F7387D94C.rev'
chaves pública e privada criadas e assinadas.

pub   rsa3072 2021-09-03 [SC] [expires: 2021-09-04]
D3EED251C38AE4F4F3EE39310DA9480F7387D94C
uid                      Oh tal doh Mattewz (mateusfg7) <mateusfg7@email.eu>
sub   rsa3072 2021-09-03 [E] [expires: 2021-09-04]

A Chave Pública

A key-pair já foi gerada e salva no nosso keyring (chaveiro), agora queremos visualizar a nossa chave pública. Primeiro listamos nossas chaves, para isto, usamos a opção --list-key.

$ gpg --list-key

Irá aparecer várias chaves, e por último a chave que acabamos de criar. Podemos extrair algumas informações importantes da nossa chave, como:

• Algorítimo usado e o tamanho da chave: rsa3072.
• A data de criação da chave: 2021-09-03.
• A data de expiração da chave: 2021-09-04.
• E o fingerprint (digital) da chave: D3EED251C38AE4F4F3EE39310DA9480F7387D94C.
  

É com o fingerprint da chave que usaremos para fazer algumas operações com ela.

Exportar

Primeiro precisamos exportar nossa chave para poder compartilhar com outras pessoas. Pediremos o gpg para exportar a chave, usando a opção --export. Também usaremos a opção --armor, para exportar a chave no formato ASCII, sem essa opção a chave será exibida com vários caracteres estranhos.

sem a opção --armor

com a opção --armor

Essa saída não é muito fácil de decorar, então costumamos a direcionar essa saída para um arquivo. Para isto usamos a opção --output, esse comando por sua vez recebe o nome do arquivo de destino como argumento. Por convenção, criamos esse arquivo com a extensão .pub, de public. Logo após, passaremos o fingerprint da chave que queremos exportar. Nosso comando ficará assim:

$ gpg --export --armor --output minha_chave.pub D3EED251C38AE4F4F3EE39310DA9480F7387D94C

É esse arquivo que disponibilizaremos de forma pública.

Importar

Para importar uma chave pública para nossa keyring usamos a opção --import, e o arquivo da chave:

$ gpg --import minha_chave.pub

Publicar

Podemos publicar a nossa chave de forma pública em servidor de chave na internet, para isto basta usar a opção --send-keys e o fingerprint da chave pública que você deseja publicar:

$ gpg --send-keys D3EED251C38AE4F4F3EE39310DA9480F7387D94C

No meu caso minha chave foi enviada para hkps://keys.openpgp.org, se o seu for diferente não tem problema.

Para pesquisar uma chave bastar usar a opção --search-keys seguido do fingerprint da chave ou o email da pessoa que você quer pesquisar:

gpg --search-keys D3EED251C38AE4F4F3EE39310DA9480F7387D94C

Editar

Nós também podemos editar nossa chave. Para isto, usamos a opção --edit-key mais o fingerprint da chave que queremos editar:

$ gpg --edit-key D3EED251C38AE4F4F3EE39310DA9480F7387D94C

Após rodarmos o comando, ira abrir um shell interativo do próprio gpg, com inúmeros comandos e opções para poder editar, para ver todas, basta digitar o comando help.

Para exemplificar, mudarei a data de expiração da minha chave para 0, ou seja, vou desativa-la. Após rodar o comando, será pedido o tempo para chave expirar e a senha da chave, para poder realizar as alterações.

gpg> expire
Modificar a data de validade para uma chave primária.
Por favor especifique por quanto tempo a chave deve ser válida.
  0 = chave não expira
  <n>  = chave expira em n dias
  <n>w = chave expira em n semanas
  <n>m = chave expira em n meses
  <n>y = chave expira em n anos
A chave é valida por? (0) 0
Key does not expire at all
Is this correct? (y/N) y

sec   rsa3072/0DA9480F7387D94C
      created: 2021-09-03  expires: never       usage: SC
      trust: ultimate      validity: ultimate
ssb   rsa3072/A42BFA763F8E415E
      created: 2021-09-03  expires: 2021-09-04  usage: E
[ultimate] (1). Oh tal doh Mattewz (mateusfg7) <mateusfg7@email.eu>

gpg: WARNING: Your encryption subkey expires soon.
gpg: You may want to change its expiration date too.

Para salva as alterações e sair do modo interativo, basta digitar quit. Pronto, minha chave agora não tem mais uma data de expiração.

Usando o key-pair

Criptografando arquivos

Para criptografar um arquivo, usamos a opção --encrypt, seguido da opção --recipient, que por sua vez tem como parâmetro o fingerprint de quem receberá a mensagem/arquivo criptografado. Nosso comando final ficará assim:

$ gpg --encrypt --recipient 5863874C7BBAFFE7829FB89C4151BFF1C8B0B523 mensagem.txt

Descriptografando arquivos

Para descriptografar um arquivo usando a chave privada, basta usar a opção --decrypt, e o arquivo criptografado:

$ gpg --decrypt mensagem.txt.gpg

Assinando mensagens

Outra função só gpg é assinar mensagens, imagine um cenário em que você não quer esconder a mensagem, e sim certificar que foi você quem escreveu a mesma. Esse é o objetivo de assinar mensagens, a ideia é você usar a chave privada para assinar a mensagem, e alguém que queira validar que aquela assinatura é sua, irá usar a sua chave pública.

Digamos que escrevi algo muito importante para a humanidade, salvei em um arquivo, e quero assinar esse arquivo, para provar que a descoberta foi minha. Para isto assinaremos a mensagem usando a opção --clear-sign, depois usaremos a opção --default-key, com o fingerprint da chave que será usada para assinar a mensagem, e o arquivo a ser assinado:

$ gpg --clear-sign --default-key D3EED251C38AE4F4F3EE39310DA9480F7387D94C mensagem.txt

Para verificar a mensagem, basta usar a opção --verify, e o arquivo assinado:

$ gpg --verify mensagem.txt.asc

Se alguém alterar a mensagem, a verificação de assinatura irá falhar.

Também podemos assinar um arquivo binário, como PDF, imagem, vídeos, executáveis binários, etc. O processo para assinar esse tipo de arquivo será um pouco diferente porque não se abre um arquivo binário para ler, então o gpg criará outro arquivo separado onde contem a assinatura, e para verificarmos se nosso binário é válido, precisamos tanto do arquivo original quanto do arquivo de assinatura. Primeiro criaremos um arquivo binário com dados aleatórios para fins educacionais, mas o processo pode ser feito com qualquer arquivo binário.

$ dd if=/dev/zero bs=1000000 count=10 > binary.dat

Para assinarmos arquivos binários usaremos a opção --sign, também usaremos a opção --default-key com o fingerprint da chave que usaremos para assinar o arquivo, e o arquivo:

$ gpg --sign --default-key D3EED251C38AE4F4F3EE39310DA9480F7387D94C binary.dat

Com isso o gpg gerará um outro binário contendo a assinatura do arquivo.

Para verificar a assinatura o processo é mesmo citado acima.

Backup

O backup da chave privada é extremamente importante, pois se você perder o dispositivo onde esta armazenada a chave privada, não há nenhum meio de recupera-la. Para exportar a chave privada, usamos a opção --output seguido do arquivo de saída da chave, depois a opção --export-secret-keys seguido do fingerprint da chave que deseja exportar:

$ gpg --output private_key.key  --export-secret-keys D3EED251C38AE4F4F3EE39310DA9480F7387D94C

Para importa-la basta usar a opção --import e o arquivo:

$ gpg --import private_key.key

Conclusão

Esse foi só um apanhado do básico do GnuPG, há muito mais a se fazer com essa ferramenta. Para conhecer melhor ela basta usar a opção --help, que será listada todas as opções possíveis, ou até, no caso de sistemas Linux, usar o comando man seguido do programa que você quer ver o manual, no caso:

$ man gpg

Isto irá abrir o manual do comando gpg.

Você também pode conferir o site oficial do GnuPG, listado abaixo nas referências.

Referências

GnuPG: https://gnupg.org/ [archive]

Conheça o PGP: mensagens INVIOLÁVEIS com criptografia assimétrica: https://www.youtube.com/watch?v=p_TYYOtA2LU

Tutorial GPG (em português): https://www.youtube.com/watch?v=r8k-jJ-EHP8

How to Encrypt and Decrypt Files With GPG on Linux: https://www.howtogeek.com/427982/how-to-encrypt-and-decrypt-files-with-gpg-on-linux/ [archive]

How to specify private key when decrypting a file using GnuPG?: https://superuser.com/questions/920793/how-to-specify-private-key-when-decrypting-a-file-using-gnupg [archive]

Encrypt and sign with specific secret key: https://unix.stackexchange.com/questions/171715/encrypt-and-sign-with-specific-secret-key [archive]

How to create binary file using Bash?: https://stackoverflow.com/questions/8521240/how-to-create-binary-file-using-bash [archive]

“PGP” and “GPG” stand for “Pretty Good Privacy” and “Gnu Privacy Guard.” These are two different computer programs developed to protect electronic communications. Today almost everyone uses emails for correspondence and communication, but this medium is not as secure as we think it is. The emails can easily be forged by someone using anybody’s name or identity, and the emails can easily be stored and read by people with special skills. To solve these existing problems and improving the security of emails as well as making them more private, these two programs were developed and used. The privacy of emails is maintained by these programs because they allow encryption of messages by people, and only the people who are authorized can read the encrypted messages; secondly, they are difficult to forge.

For these programs to run properly, the computer used should be secure. If the computers are easily infected with viruses or attacked by spyware programs which can report the key to someone, then first the computer needs to be secure to implement the full strength of these programs.

PGP

“PGP” stands for “Pretty Good Privacy.” It was developed by Phil Zimmermann. At first it was written as copyrighted freeware under the Gnu Public License. Later, PGP was upgraded and made into a propriety program. The rights for this program are traded around. The reason for this upgrade was legal defense costs and royalty issues related to the export laws of the USA. Now the PGP program is owned by PGP Corporation. Only the command line version is not owned by PGP Corporation which is also not for sale. PGP uses the RSA algorithm and the IDEA encryption algorithm. The PGP is considered to have Windows interface which is more polished.

GPG

“GPG” stands for “Gnu Privacy Guard.” GPG is a re-write or upgrade of PGP. It does not use the IDEA encryption algorithm. This is to make it completely free. It uses the NIST AES, Advanced Encryption Standard. All the algorithm data is stored and documented publicly by OpenPGP Alliance. The main reason for this change is that AES costs less than IDEA and is considered more secure. Moreover, it is royalty free because it is not patented. GPG is more compatible than the original PGP with OpenPGP. GPG is also based on a command line. Windows frontends are also available for GPG other than the command line.

The freeware version of the PGP program can be downloaded from the home page of PGP International. It is restricted for personal use and is not for commercial purposes, or one can buy it from PGP Corporation. The free digital signature and email encryption program can be downloaded from GPG if it is for personal as well as for business use.

Summary

1. “PGP” stands for “Pretty Good Privacy”; “GPG” stands for “Gnu Privacy Guard.”
2. It was the original freeware copyrighted program; GPG is the re-write of PGP.
3. The PGP uses the RSA algorithm and the IDEA encryption algorithm. GPG uses the NIST AES, Advanced Encryption Standard.
4. A freeware version of the PGP program can be downloaded from the home page of PGP International. It is restricted for personal use and is not for commercial purposes. The free, digital signature and email encryption program can be downloaded from GPG if it is for personal as well as for business use.

referencies

Difference Between PGP and GPG: http://www.differencebetween.net/technology/software-technology/difference-between-pgp-and-gpg/ [archive]

Just create a interface and add the type with the property read only. After, add the interface to the tag declaration with < >:

interface Props {
  readonly color: string
}

const Text = styled.h1<Props>`
  color: ${(props) => props.color};
`

const Component = () => <Text color='white'>Title</Text>

export default Component

referencies

Using custom props: https://styled-components.com/docs/api#using-custom-props [archive]

"Usem linux… porque no linux não tem vírus?"

Notas baseadas na live "Segurança em Linux — Christiano Linuxman | ROADSEC@HOME#37" da Roadsec, no YouTube.

Identificação de usuários

Permissões

Manipulação de arquivos

Tudo no linux é arquivo ou pasta. A ordem de permissão de manipular esses arquivos é:

A hierarquia de permissões se da por:

• Pasta
  • Arquivo
  • Arquivo

Umask

umask - user mask - 0 022

A umask influencia na permissão de criação de diretórios e arquivos. A umask é um padrão a nível de kernel.

Toda vez que criarmos uma pasta/arquivo, será subtraído a nossa umask (022) da permissão máxima (777), e o resultado será a permissão desta pasta/arquivo.

mkdir mateus_pasta

$777 – 022 = 755$

7rwx 5r-x 5r-x

No caso do arquivo, será subtraído mais 1 bit de cada permissão (111).

touch arquivo

$755 - 111 = 644$

6rw- 4r-- 4r--

O d junto com as perimções indica que o arquivo é um diretório.

Permissões especiais

Existem também as permissões especiais de usuário, representado pelo primeiro número da umask 0022.

Imagine o cenário que precisamos que alguém execute o comando shutdown, porem não queremos passar a senha de root. Podemos dar a permissão SUID BIT para o binário shutdown:

$ chmod 4755 /sbin/shutdown

Assim, qualquer usuário pode executar o comando shutdown com poder de root sem precisar ser root.

O mito

1. (P.) Arquivos criados pelo usuário têm a permissão 644.
2. (P.) Um vírus é um binário com poder de execução.
3. (1) Um usuário não pode criar um binário naturalmente.
4. (2, 3) ∴ Sem binários, sem vírus.

Manipulando arquivos no lugar certo

Libs

Para cada comando no linux, precisamos de bibliotecas para funcionarem (equivalentes a DLLs do Windows). Então como sei as libs necessárias para rodar um determinado comando? É só usar o comando ldd.

Ambiente Ubuntu 20.04 no KataCoda

$ which ls
/usr/bin/ls

$ ldd /usr/bin/ls
linux-vdso.so.1 (0x00007ffe4b5fc000)
libselinux.so.1 => /lib/x86_64-linux-gnu/libselinux.so.1 (0x00007f1e050ec000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f1e04efa000)
libpcre2-8.so.0 => /lib/x86_64-linux-gnu/libpcre2-8.so.0 (0x00007f1e04e6a000)
libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007f1e04e64000)
/lib64/ld-linux-x86-64.so.2 (0x00007f1e05147000)
libpthread.so.0 => /lib/x86_64-linux-gnu/libpthread.so.0 (0x00007f1e04e41000)

Agora executando o comando ldd nos binários cat e wget:

$ ldd /bin/cat
linux-vdso.so.1 (0x00007ffeddfd2000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f9923dc0000)
/lib64/ld-linux-x86-64.so.2 (0x00007f9923fc9000)

$ ldd /bin/wget
linux-vdso.so.1 (0x00007ffcbd989000)
libpcre2-8.so.0 => /lib/x86_64-linux-gnu/libpcre2-8.so.0 (0x00007fbdc6c35000)
libuuid.so.1 => /lib/x86_64-linux-gnu/libuuid.so.1 (0x00007fbdc6c2c000)
libidn2.so.0 => /lib/x86_64-linux-gnu/libidn2.so.0 (0x00007fbdc6c0b000)
libssl.so.1.1 => /lib/x86_64-linux-gnu/libssl.so.1.1 (0x00007fbdc6b78000)
libcrypto.so.1.1 => /lib/x86_64-linux-gnu/libcrypto.so.1.1 (0x00007fbdc68a2000)
libz.so.1 => /lib/x86_64-linux-gnu/libz.so.1 (0x00007fbdc6886000)
libpsl.so.5 => /lib/x86_64-linux-gnu/libpsl.so.5 (0x00007fbdc6871000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fbdc667f000)
libpthread.so.0 => /lib/x86_64-linux-gnu/libpthread.so.0 (0x00007fbdc665c000)
/lib64/ld-linux-x86-64.so.2 (0x00007fbdc6d5e000)
libunistring.so.2 => /lib/x86_64-linux-gnu/libunistring.so.2 (0x00007fbdc64da000)
libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007fbdc64d4000)

Há uma semelhança notável entre os 3 binários, a biblioteca libc.so.6.

A maioria dos comandos linux usam essa biblioteca para funcionarem. Mas se mudarmos o nome desse arquivo e tentarmos executar o ls?

O sistema sentou. Bem, para resolver isso é só dar o mv de volta…

Inicialização do Linux

No linux temos 6 tipos de runlevel, são eles:

Então se eu souber qual é o primeiro processo, que é o init e chamar o runlevel 0 a máquina irá desligar.

$ init 0

Estamos no level 5, podemos conferir isso rodando o comando runlevel:

O N significa que não ouve nenhuma alteração de um runlevel dês da última inicialização. Podemos alterar esses runlevel, e eles estão associados a nossas pastas, se irmos ate a pasta /etc teremos uma pasta para cada runlevel:

Na pasta rc5.d, por exemplo, temos alguns processos que não irão subir, iniciador pela letra K (kill), e alguns que irão subir, iniciados pela letra S (start), neste determinado runlevel (5).

No arquivo /etc/inittab, na segunda linha temos:

id:5:initdefault

Oque aconteceria se mudarmos esse número de 5 para 6, e desligarmos, logo após, alguém ligar o PC para navegar na internet? A sequência é:

id:5:initdefault

• Botão Power
  • BIOS/MBR
    • gerenciador de boots (grub2)
      • kernel
        • init
          • DM
            • DE (onde estamos)

id:6:initdefault

• Botão Power
  • BIOS/MBR
    • gerenciador de boots (grub2)
      • kernel
        • init = 6 (reboot)

Caímos em um loop.

Privilege Escalation

Vamos tentar fazer um ataque de privilege escalation em um Linux, usando as permissões como área de exploração.

Primeiro vamos pesquisar na raiz do sistema, todo arquivo que tenha a permissão 4000, com o comando find / -perm -4000 2>/dev/null:

Obteremos vários resultados úteis, mas o que queremos é o cpulimit:

O cpulimit tem a permissão SUID BIT, ou seja, quando executa-lo ele irá trabalhar como root. Sendo assim, podemos criar uma pasta na raiz executando o comando cpulimit -l 100 -r mkdir /pasta, mesmo como um usuário comum:

Bem, se podemos executar um binário como root, e se usarmos isso para dar permissão SUID BIT também no binário bash?

1. Dou permissão SUID BIT para o binário bash

$ cpulimit -l 100 -f chmod 4755 /usr/bin/bash

referências

Segurança em Linux - Christiano Linuxman | ROADSEC@HOME#37: https://www.youtube.com/watch?v=AzB5BNDTXOk

A subprocess is OS process that runs inside of another process father. The subprocess module allows to run subprocess with Python.

We can use subprocess to run shell commands in a better way than os.system module.

Execute a command

Now, we can just run a command to see the files in the current folder. In Linux we will run the ls command, like this:

The -l option is to show the details of the files.

To run this with subprocess we need to run the call() function. The first param of the function is an list, with the command, where each value of the list is an option of the command:

subprocess.call(['ls', '-l'])

Otherwise we can use a simple string. e.g.: 'ls -l'

Check command output

To check the output of the command we will use the function check_call(). Why not use call(), again? If occurs an error in the command execute, the call() will just show the error, without the possibility of handling this error. The same not occurs with check_call(), we can get the error, and handling it.

import subprocess

try:
    subprocess.check_call(['cat', 'file_1.py'])
except Exception as E:
    print(E)

Get the command output

To save the output of the command in a variable, we will use check_output().

import subprocess

o = subprocess.check_output(['cat', 'file_1.py'])

print("Output:", o)

Popen: icing on the cake

The function Popen is like call(), but their return an object with several object to handler the output, error, etc.

Lets run a python program:

subprocess.Popen('python3 file_1.py', stdout=subprocess.PIPE, shell=True).stdout.read()

The stdout=subprocess.PIPE param defines that the output of the subprocess is not the terminal, but the own process. The shell=True defines that the process will run in the own command line.

We are getting the stdout object of Popen, and running the read() function to read the output of the command.

referencies

Aulas Python - 114 - Ferramentas de Sistema X: Módulo subprocess: https://www.youtube.com/watch?v=jgmIUa2_wSY

Self-Host softwares is the softwares that you can upload an instance on your own web server, gaining control and privacy, without depending on third parties.

It is highly recommended to upload instances in a docker container.

Softwares

Storage

Alternatives to: Dropbox, Mega, Google Drive, OneDrive, Mediafire...

Nextcloud: Nextcloud is a suite of client-server software for creating and using file hosting services. It is enterprise-ready with comprehensive support options. Being free and open-source software, anyone is allowed to install and operate it on their own private server devices.

Tahoe-LAFS: Tahoe-LAFS is a Free and Open decentralized cloud storage system. It distributes your data across multiple servers. Even if some of the servers fail or are taken over by an attacker, the entire file store continues to function correctly, preserving your privacy and security.

Tonido: Tonido Server allows you to access all your files on your computer from a web browser, smartphone, tablet or even DLNA enabled devices. Easy to get started: just install the Tonido Server software and your computer turns into a private cloud server. Easy to remember link to your computer. e.g.: http://john.tonidoID.com.

ownCloud: Access, Sync and Share Your Data, Under Your Control! ownCloud is a self-hosted file sync and share server. It provides access to your data through a web interface, sync clients or WebDAV while providing a platform to view, sync and share across devices easily — all under your control. ownCloud’s open architecture is extensible via a simple but powerful API for applications and plugins and it works with any storage.