DEV Community: Thomas Lincoln

Bar Programming #03 — Clean Code Chapter 1

Thomas Lincoln — Tue, 02 Jul 2024 13:41:22 +0000

In the today post, I will write a resume of what I learn and understood about the first chapter of “Clean Code”, probably I will write more texts like this about the other chapters. So, if you have interest in Clean Code or want to understand a little about, you are more than welcome to continue reading this possible series.

The Clean Code book was written by Robert Cecil Martin, aka Uncle Bob, in this book he covers technics, rules, and ideas. Which aim to improve the readability of codes and to improve the efficiency of the development.

In the first chapter, the following topics are covered:

What is a Bad Code?
Which is the cost of have a bad code?
What is Clean Code?
Recommendations

What is a Bad Code?

To explain the importance of a good code, the Uncle Bob quotes an example of an application developed in the 80s, that became some popular. But, interval between the updates start to increase, the bugs were not fixed, and the time of loading and crashes start to increase so much. Until it reaches a point, it was unusable.

After a time, he meet one of the workers, and found that the reason behind this chaos, it was as expected. The code start to became incomprehensible, more and more makeshift, so that it was not possible to update or do maintenance.

Why we write a bad code?

But, why? Why we write a bad code? The bad code has power to retard us, a good possible reason can be the hurry, because, we have deadlines to finish our tasks, the demands need to be completed, we can't lose our time cleaning the code.

Or same, the wear and tear of working in that project is turning big, to the point what we want just end this once and for all, and throw it aside.

The cost of having a bad code

We can see the cost of having a bad code, when we read someone else's code, and the fact that it is confusing, makes us work more slowly, or same, our own code can produce the same effect. Even when we start fast, we can suddenly to perceive that we are more and more delaying to achieve progress.

This happens, because these errors are like a snowball, the more we leave aside, the more we postpone the cleaning time, the slower it will our progress. According to the author, these bugs make the team productivity get closer to zero.

Therewith in mind, the author says that even if we think “I need to fulfill the demand, if not I will be fired”, we need to communicate to our superiors, and to warn that such a demand need more time. We need to protect our code, we need to defend that it requires more attention, so that so, don't happen the same thing that happen with the press before mentioned.

What is Clean Code?

Let's say you believed in me, that a bad code is an obstacle for the creation of a software, and think you want to develop a good code, so, how to write a clean code?

It should be noted that write a clean code, is not as simple as flipping a switch in our heads, is necessary to have a sensitivity in relation to the code. Understand which are the things that are turning our code in a bad code, and which technics can be applied to resolve.

Write a clean code is like to draw, be able to evaluate if a drawing is good or not, don't make you able to draw, so, is necessary to have knowledge of technics and strategies.

So, going to the main question, we can summarize a clean code in a code that follows that four rules:

Without duplication, do not exist any repeated features.
One task, the code must have only one function, and your functions too, everything must do only one thing.
Expressiveness, the code must be very clear in relation with the name of the things.
Little abstractions, this rule involves the creation of methods and classes that encapsulate specific features in a clear way, without becoming excessively complex or multifunctional.

In general, we can describe a clean code, paraphrasing Ward Cunningham:

A clean code, he makes exactly what you think, is like if the language was be made for make that thing, nothing surprise you, everything is how you expected.

Recommendations

Of course, the rules to make a clean code can vary too much, don't exist only the rules mentioned in the “Clean Code” book, because, this is the author vision. Of course, his vision is supported and used for many people, but still, not all will think that this is the better way to make a clean code. But the author recommends, that we read it, learn with him and decide for ourselves.

So, he says that for him and your colleagues, these rules are the best, but, don't recommend that we think in this way, because it is possible that we can reject one or other rule.

Uncle Bob also says to us, that we have the responsibility to write a code that is easy to read, in the end, while we write a code, a good part of the job is read another codes. When we are reading, we want this reading to be easy to understand. So, we need to write a code thinks that someone will read it, aiming to write something that is easy for other people to read.

Finally, the Uncle Bob also say, to us follow boy scout rule:

Make the area of camp better that when you find it.

The idea behind this recommendation, is that instead of we only write a clean code, we must do maintenance. In other words, we must constantly think in clean improvements to our code, and this doesn't need to be a big thing, change a name of a variable is enough.

Conclusion

With this, we can understand the need and importance to have a clean code, besides understanding what is a clean code. In the next chapter, we will understand how we can give better names to our children (variables and functions).

Bar Programming #02 - How to use GitHub Actions to provide an environment with CI

Thomas Lincoln — Wed, 06 Mar 2024 15:00:00 +0000

Today, I will write a basic guide to understand and use GitHub Actions.

First, we have a YAML file, in this file we have all the configurations about our automation. This file specifies, Events, Jobs, Runners, Steps and Actions.

But, before we go to GitHub actions, we need to understand when this code will run. In GitHub actions, we have "triggers".

An event is a trigger in our workflow, with this, we can understand when something to happened, an example is a “push”.

For use the GitHub Actions, you have to create a YAML file in a folder name .github/workflow, in this folder you create something like myWorkflow.YAML

An example of a YAML file:

---
name: Lint

on:  # yamllint disable-line rule:truthy
  push: 
    branches: [main]
  pull_request: 
    branches: [main]

jobs:
  build:
    name: Lint
    runs-on: ubuntu-latest

    permissions:
      contents: write
      packages: write
      # To report GitHub Actions status checks
      statuses: write

    steps:
      - name: Checkout code
        uses: actions/checkout@v4
        with:
          # super-linter needs the full git history to get the
          # list of files that changed across commits
          fetch-depth: 0

      - name: Super-linter
        uses: super-linter/super-linter@v6.2.0  # x-release-please-version
        env:
          # To report GitHub Actions status checks
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          VALIDATE_CHECKOV: false

...

Now, an explanation of the things you read:

name is the name of your workflow, but, this is optional
on, is where you select the triggers. In this case, we will listen to the push and pull request.
branches, this is which branch you will listen to
jobs, this is your task, you will test your code? Verify the style of code?
build, this is the recipe of your build, the steps.
permissions, this defines how much access the workflow will have.
steps, and finally, this is the steps of your process.
name (inside of steps), the name of this step.
uses, this is used to add a pre-existing action to your workflow, simplifying and reusing code.
with, allows you to pass parameters and settings to the action you are including, customizing its behavior.
env, defines environment variables that can be used at any step in the workflow.

Obs: In your YAML, you have to put more attention to your code indentation.

With this, when you or a college make a push or a pull request, the GitHub will be tested for you.

Now, I will show for you where and how to make this.

I will use this repository.

Now, I will add a file without any indentation and bad code style.

And finally, make a pull request:

Now, you can see the test running, and if all run how I expected:

We have some errors in our linter workflow, and if you want to know what and where, just click in details:

By resolving the error, we received positive feedback, so you can run automated tests before accepting a pull request, or before merging your branches.

Bar Programming #01 - What is CI/CD and how its works

Thomas Lincoln — Wed, 28 Feb 2024 15:00:00 +0000

Today, I will talk about CI/CD, a strategy to create and update as most fast as can. With this tool, you will never need to spend hours merging all branches of your project.

Obs: For now, I will write in English, because I really focus on devolving my English writing.

What is CI/CD?

CI is an acronym to Continuous Integration, with this part, our focus is on to constantly integrate and merge the code. CD Continuous Delivery, and with this, we want constantly to deliver features and updates to our production server.

For your better understand, I get an infographic from Red Hat website.

(Is hard to see in dark mode)

In a more directly way, CI wants to avoid the merge hell day and the CD wants to make the main branch is updated and ready for deploy.

Why would you use CI/CD?

The goal of this strategy is to prevent bugs and conflicts by testing code before merging it, and by maintaining a cycle of constant updates. As applications grow in scope, these techniques help to reduce project complexity and make development more efficient.

Thanks to the automatic tools of CI/CD, human intervention is not necessary when adding a commit to the production area. This means that updates reach the deployment area faster and users receive updates more frequently. This allows their feedback to reach developers sooner.

Delving deeper into CI

What is CI?

CI stands for “Continuous Integration”. It is a software development practice that involves frequently merging code changes into a shared repository. This practice helps to prevent bugs and conflicts by identifying and fixing problems early in the development process.

Why is CI important?

In modern software development, it is common for multiple developers to work on different parts of the same codebase. This can lead to issues when it comes time to merge the changes together. For example, changes made by one developer may conflict with changes made by another developer.

CI helps to prevent these issues by automating the process of merging code changes. When a developer makes a change to the code, they commit the change to a local repository. The CI server then automatically pulls the latest changes from the local repository and merges them into the shared repository.

How does CI work?

The CI process typically involves the following steps:

A developer makes a change to the code and commits the change to a local repository.
CI server pulls the latest changes from the local repository.
CI server runs a series of tests to ensure that the changes do not break the code.
the tests pass, the CI server merges the changes into the shared repository.
the tests fail, the developer is notified and must fix the problem before the changes can be merged.

Delving deeper into Continuous Delivery (CD) and Continuous Deployment (CD)

What is CD?

CD stands for "Continuous Delivery" and/or "Continuous Deployment." These are two related concepts that deal with the final stages of the software development process.

Continuous Delivery

The goal of continuous delivery is to ensure that a software application can be released to production at any time. This is achieved by using automated tests to verify that the code is working as expected. If the tests pass, the code is automatically deployed to a staging environment. In this environment, the code can be further tested and evaluated before it is released to production.

Continuous Deployment

Continuous deployment is a step beyond continuous delivery. It involves automatically deploying the code to production whenever a change is made to the codebase. This means that new features and bug fixes can be released to users as soon as they are ready.

Bar Programming #00 - ThreeJS, como criar cenas 3D na web

Thomas Lincoln — Wed, 20 Dec 2023 19:16:12 +0000

Hoje, como teste dessa possível série de posts, tudo dependerá da minha disponibilidade de tempo, e de ter um bom assunto para falar. Mas, aqueles que estão aqui, bem vindos ao beta da minha programação de bar, onde falarei um pouco sobre algum assunto de programação, alguma tecnologia, tentando sempre falar de forma descontraída e leve, abstraindo um pouco, para o texto ser tranquilo de ler.

Ps: Todos os links, que usei de referência, irão estar

No post dessa vez, planejo explicar um pouco sobre como funciona a biblioteca threejs, mas antes, daremos um breve contexto sobre o que é o threejs.

O que é ThreeJS?

Three.js é uma biblioteca JavaScript que permite criar e renderizar gráficos 3D na web. Com ela, você pode criar cenas, objetos, luzes, materiais, texturas, animações, efeitos e muito mais, usando apenas o seu navegador.

Um exemplo de projeto usando three.js: Projeto

O Three.js é uma ferramenta poderosa e divertida para criar gráficos 3D na web, mas também tem suas limitações e desafios. Por exemplo, você precisa se preocupar com a compatibilidade dos navegadores, o desempenho, a otimização, a interação, a física, a iluminação, etc.

Hora de programar!

Agora com esse conhecimento em mãos, vamos tentar, fazer algo simples, como um quadrado girando no cenário, será nosso primeiro de muitos mergulhos, pois, gostaria que você volte para outros, agora chega de conversa, e vamos por a mão na massa.

Primeiramente, o html você pode copiar e colar sem dó, apenas prestando atenção que eu linkei um script da própria biblioteca e também um src para o app.js, o qual precisa ser do tipo “module”:

<!DOCTYPE html>
<html lang="pt-br">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="style.css">
    <title>A Square</title>
</head>
<body>

    <script type="importmap">
      {
        "imports": {
          "three": "https://unpkg.com/three@0.139.2/build/three.module.js",
          "three/addons/": "https://unpkg.com/three@0.139.2/examples/jsm/"
        }
      }
    </script>
    <script src="app.js" type="module"></script>
</body>
</html>

O css também:

body{
    background-color: rgb(20, 19, 19);
    width: 100%;
    height: 100%;
}

Agora, vamos por parte no javascript, primeiro, precisamos criar a nossa cena, que será, basicamente, o ambiente em que trabalharemos. Também precisamos criar uma câmera, pois sem ela não veremos nada e por fim, criar um renderer, que irá renderizar a nossa cena.

Ps: Também adicionaremos os imports iniciais que usaremos.

import * as THREE from 'three';
import { OrbitControls } from 'three/addons/controls/OrbitControls.js';

let scene = new THREE.Scene();
let camera = new THREE.PerspectiveCamera(75,window.innerWidth/window.innerHeight, 0.1, 1000);
let renderer = new THREE.WebGLRenderer();
renderer.setSize( window.innerWidth, window.innerHeight );
renderer.shadowMap.enabled = true;
document.body.appendChild( renderer.domElement );

Essa variável scene será extremamente usada, sempre que quisermos adicionar algo na cena, seja um objeto, uma luz, um chão, ect. Tudo será adicionado nela com um método scene.add(o que você quiser adicionar).

Agora, num primeiro momento, criemos um cubo, a explicação para cada item será dada a seguir.

let geometry = new THREE.BoxGeometry(1, 1, 1);
let material = new THREE.MeshBasicMaterial({ color: 0x00ff00 });
let cube = new THREE.Mesh(geometry, material);
scene.add(cube);

Bom, primeiro, o objeto precisa ter uma geometria, sendo basicamente um formato, como se fosse o esqueleto dele, depois disso, temos o material, que seria a pele do nosso cubo. Assim, nós juntamos tanto esqueleto e pele, na construção do cubo usando um new THREE.Mesh(geometry, material), e por fim, usando a variável anteriormente criada, nós adicionamos na cena.

Mas no momento, tanto a câmera quanto o cubo, nasceram no mesmo lugar, no 0,0,0. Então, temos algo assim:

Para isso, afastemos um pouco usando o eixo z (caso não entenda direto, pense apenas que estamos andando um pouco para trás ou para frente com a câmera), e também, renderizemos na tela o cubo.

camera.position.z = 5;
renderer.render(scene, camera);

Tá, mas esse cubo ta meio chato e parado não é? Façamos o seguinte, vamos rotacionar ele no eixo x e no y.

cube.rotation.x += 1;
cube.rotation.y += 2;

Com todas essas mudanças, no momento nosso projeto se encontra assim:

Agora, com nosso cubinho em mão, proponho tentar melhorar a cena, talvez com um pouco de luz e sombra e com alguma animação para finalizar.

Primeiro a animação, que acaba sendo bem simples, lembra que movemos o objeto, chamando um .position.eixo? Então, nós apenas precisamos fazer isso repetidas vezes, para isso, precisamos criar uma função animate() e chamar uma função chamada requestAnimattionFrame:

function animate() {
  requestAnimationFrame(animate);

  cube.rotation.x += 0.01;
  cube.rotation.y += 0.01;

  renderer.render(scene, camera);
}

animate();

Agora, adicionemos um plano e rotacionar, para ele ser um chão da nossa cena, apenas para melhorar a visualização.

const planeGeometry = new THREE.PlaneGeometry( 100, 100 );
const planeMaterial = new THREE.MeshStandardMaterial({ color: 0xbcbcbc });

const plane = new THREE.Mesh( planeGeometry, planeMaterial );
plane.rotation.x = -Math.PI / 2; 
plane.position.y -= 5
plane.receiveShadow = true;
scene.add( plane );

Aqui segue o mesmo esquema do cubo, com apenas a adicção de uma rotação, para ele virar um chão mesmo.

Agora, adicionemos luzes e sombras, para isso usamos o seguinte código:

const ambientLight = new THREE.AmbientLight( 0xffffff, 0.5 );
scene.add( ambientLight );

const spotLight = new THREE.SpotLight( 0xffffff, 0.7 );
spotLight.position.set(2, 12, 2);
spotLight.angle = Math.PI / 6;
spotLight.penumbra = 0.5;
spotLight.decay = 1;
spotLight.distance = 0;
spotLight.castShadow = true;
spotLight.shadow.mapSize.width = 1024;
spotLight.shadow.mapSize.height = 1024;
spotLight.shadow.camera.near = 1;
spotLight.shadow.camera.far = 60;
scene.add( spotLight );
scene.add( spotLight.target );

Coloquei algumas muitas propriedades rs, mas apenas copie elas, você pode ir modificando cada uma delas, mas são bem descritivas, então, teste a vontade.

E por fim, vou apenas adicionar um controle orbital, para podermos visualizar melhor a cena.

const controls = new OrbitControls( camera, renderer.domElement );

Com isso, você poderá rotacionar sua cena, dar zoom, tirar zoom, o que quiser livremente.

Resultado:

Muito obrigado pela atenção caso tenha chegado até aqui, espero que meu artigo tenha ajudado, qualquer ideia de post ou sugestão, por favor, me informe nos comentários.

Referências

Link do GitHub: https://github.com/ThomasLincoln/ThreejsTests
Link de referência para as luzes: https://sbcode.net/threejs/directional-light-shadow/

Arquitetura de Sistemas Operacionais #5

Thomas Lincoln — Fri, 02 Sep 2022 11:23:36 +0000

Hoje irei falar um pouco sobre as divisões anteriormente mencionadas, os tipos de sistemas multitarefa e tudo mais.

Sistema Batch

O sistema batch foi um dos primeiros sistemas, ele funcionava a partir de cartões furados. Que mais para frente começou a usar discos ou fitas e tudo mais.

Seu funcionamento era feito da seguinte forma: os programadores inseriam cartões que passavam por um leitor e enviava para o processador, enquanto ele estava processando, a parte responsável pela leitura já estava lendo o próximo programa. Assim, o problema de ter um processador ocioso era facilmente resolvido.

A principal característica desse sistema é a de não exigir interação do usuário com a aplicação. Todas as entradas e saídas de dados são implementadas por uma memória secundária. Os programas que eram executados nesse tipo de sistema eram os de cálculo numérico, compilações, ordenações, backups e tudo mais que o usuário não precisa interagir.

Atualmente os Sistemas Operacionais, simulam o processo batch.

Sistemas de Tempo Compartilhado

Os sistemas de tempo compartilhado, faziam com que o processamento fosse dividido em tempos, assim, cada processo pegava uma fatia do tempo livre, caso não houvesse uma fatia de tamanho suficiente para ele ou caso a que ele esteja usando não seja o suficiente, ele vai entrar em "stand by" até que liberem espaço de tempo para ele.

Esses sistemas geralmente permitem que o usuário interaja com ele através de terminais que incluem vídeo, teclado e mouse. Esses sistemas permitem que você se comunique com o processador usando comandos, assim sendo possível ver os arquivos armazenados no disco ou cancelar a execução de um programa.

Como é um sistema que geralmente responde em poucos segundos a maioria dos comandos e a todas as outras requisições, esses sistemas são conhecidos como sistema "on-line".

A maioria das aplicações comerciais usam esse tipo de sistema por conta do tempo de resposta razoável e custo baixo.

Sistemas de Tempo Real

Esses sistemas funcionam de forma semelhante aos de tempo compartilhado, com uma principal diferença que é a de que o tempo exigido pelos processos, nesse sistema é rígido e não pode variar, ao contrário dos sistemas de tempo compartilhado.

Nesses sistemas não existe o conceito de fatia de tempo, o processo vai usar o processador o tempo que for, ou até a aplicação definir que existe outra aplicação com maior prioridade, assim trocando de processo no processador.

Esses sistemas são geralmente aplicados em coisas como controle de processos, monitoramento de refinarias, controle de tráfego aéreo, etc. Em resumo, sistemas em que o tempo de processamento é um fator crucial para o bom funcionamento.

No próximo post irei falar um pouco sobre os sistemas com múltiplos processadores.

Arquitetura de Sistemas Operacionais #4

Thomas Lincoln — Thu, 01 Sep 2022 12:16:38 +0000

Hoje iremos começar a falar dos tipos de sistemas operacionais. Vamos primeiro ver uma arvorezinha mostrando as versões do sistema.

Alguns desses sistemas tem divisões, então vamos com calma, vou primeiro explicar a diferença entre os sistemas monotarefa e multitarefa.

Sistemas Monoprogramáveis ou Monotarefa

Esses eram os primeiros sistemas operacionais, eles surgiram entre 1960 e 1970, eram feitos para executarem apenas um processo por vez (o que deu origem ao seu nome), não era possível pedir para o programa executar outro processo enquanto o atual não fosse finalizado totalmente.

Assim, o processador ficava ocioso enquanto aguardava alguma entrada ou saída finalizar, ocasionando num problema de mau uso de processamento.

Sistemas Multiprogramáveis ou Multitarefa.

Nesse tipo de sistema, os recursos são compartilhados, não sendo mais um sistema que fica ocioso enquanto um processo não é finalizado. Várias aplicações podem compartilhar o processador e a memória. Assim o SO se preocupa além de fazer o contato entre os componentes, se preocupa agora a gerir os recursos para controlar quem tem acesso ao que e quando do hardware.

A principal vantagem desse tipo de sistema é a redução de custos, visto que a é possível compartilhar recursos. Além disso, eles reduzem totalmente o tempo de execução das aplicações. Porém, uma desvantagem é que a sua implementação se torna muito mais complexa do que os sistemas monotarefa.

Também podemos dividir esse tipo de SO em dois grupos dependendo da quantidade de pessoas que o acessam, os dois grupos são: os sistemas monousuário e multiusuário.

Monousário são os sistemas em que o computador é acessado por apenas um usuário, geralmente é o caso de computadores pessoais e estações de trabalho, onde apenas um usuário interage com o sistema.

Multiusuário são os sistemas em que existem vários terminais e vários computadores podem compartilhar entre si os recursos de um mesmo computador central.

Além disso, há outra divisão entre os sistemas multitarefa que diz respeito a como suas aplicações são gerenciadas, sendo essas divisões o sistema batch, de tempo compartilhado ou tempo
real.

Os quais irei falar em um post futuro

Arquitetura de Sistemas Operacionais #3

Thomas Lincoln — Sat, 27 Aug 2022 16:59:36 +0000

E agora para finalizar a história dos Sistemas Operacionais do livro, vamos para os anos 1980 e 1990, depois disso o livro apenas faz especulações, mesmo que algumas tenha realmente acontecido, eu prefiro falar apenas sobre os assuntos que o livro dá uma afirmação.

Década de 1980

Nos anos 80 foi dada a largada para os PC's, graças a IBM, que criou a filosofia de computadores pessoais. O primeiro computador usava o processador da Intel e um sistema operacional da Microsoft.

Os sistemas que dominavam os mini e superminicomputadores, eram os sistemas multiusuários, com destaque para os baseados em Unix. Nessa época foram feitas várias melhores, com destaque para o protocolo de rede TCP/IP que é usado até hoje.

Com a evolução dos microprocessadores, principalmente os da Intel. Surgem os primeiros SO's comerciais com interface gráfica, como o Microsoft Windows e OS/2.

Os softwares de redes passam a ser fortemente ligados aos sistemas operacionais, dando origem ao SO de rede, com destaque para o Novell Netware e o Microsoft LAN Manager.

Década de 1990

Nessa época tivemos uma evolução enorme nas áreas de hardware, software e telecomunicação. O que gerou uma abertura para as aplicações evoluírem, que cada vez mais precisavam de mais armazenamento e processamento, o que ocorre até nos dias atuais.

Por conta das evoluções da internet, o TCP/IP criado na década passada passou a ser um padrão de mercado. E como a internet cresceu de forma exponencial, fez com que coisas como segurança e problema de gerenciamento/desempenho se tornassem fatores relevantes e preocupantes na hora de se desenvolver um SO integrado a rede.

A arquitetura de cliente/servidor, que antes só era aplicada em redes locais, teve um aumento de escala e passou a ser usada na internet e é assim que você consegue acessar qualquer informação independente do lugar que você esteja. E com isso surgiram várias coisas que temos hoje em dia, como: servidores web, correio e servidores de banco de dados.

Foi nessa década que os SO's baseados em interfaces gráficas pegaram de verdade e se tornaram consolidados. Em 1991 o Linux surge, o SO que é atualmente usado em diversas áreas comerciais e acadêmicos.

E nessa década ocorreu a popularização dos softwares de uso livre. Como SO's que é o caso do LINUX, banco de dados como (MySQL), servidores web (Apache), etc.

Arquitetura de Sistemas Operacionais #2

Thomas Lincoln — Wed, 24 Aug 2022 13:40:24 +0000

Hoje continuemos com o conteúdo do post passado, o da história dos sistemas operacionais seguindo o livro Arquitetura de Sistemas Operacionais. Sem mais delongas, vamos lá.

Década de 1960

O elemento de mais destaque dessa época, foi sem dúvida o multiprocessamento, pois, antes da sua criação, o computador quando estava em processo de leitura ou impressão, ele não podia executar mais nenhum programa, assim, ficando ocioso.

Porém, para resolver esse problema surgiu a multiprogramação, que permitiu que vários programas compartilhassem a memória, assim, quando um programa estava na etapa de leitura/gravação, o processador começava a executar o próximo programa.

Agora vamos para a nossa linha temporal:

Em 1963, o computador B-5000 é lançado, com o SO “Master Control Program”, o que oferecia multiprogramação, memória virtual com segmentação e multiprocessamento. E nesse mesmo ano, foi criado o primeiro supercomputador, o CDC 6000.

Em 1964, a IBM lança o System/360, que era um conceito de máquinas que podiam ter portes diferentes, mas a arquitetura era a mesma. Assim o usuário não precisava se preocupar com seus programas, ele podia comprar uma máquina mais econômica em uma primeira instância, e caso necessário comprar uma mais potente depois e ainda ter seus programas funcionando em ambas. O SO dessa máquina era o OS/360

Até esse momento, nós já tínhamos evoluído bastante. Porém, para os programadores, programar ainda era muito custoso, imagine, que se você compilar o código com um erro você pode parar ele facilmente, os programadores antes não podiam fazer isso. Caso, eles cometessem um erro, eles iriam ter que esperar horas e horas para o computador terminar de compilar aquele programa com erro.

A solução para isso foi oferecer tempo de resposta menores e uma interface para interagir melhor com o sistema. Assim cada processo estaria limitado, poderia apenas usar o processador em alguns intervalos de tempo, para isso foi dado o nome de tempo compartilhado (time-sharing). Além de adicionarem um terminal de vídeo (o precursor do monitor) e um teclado.

Um dos primeiros sistemas a usar o Time-Sharing foi o CTSS, foi feito pelo MIT em 1962, e logo após o seu lançamento, o MIT já estava se preparando para desenvolver o MULTICS.

O qual implementava várias inovações como a memória Virtual com segmentação e paginação, multiprogramação e suportava vários usuários e processadores. Porém, ele não pode ser finalizado, contudo, muitas das ideias desenvolvidas nele foram importantes para o desenvolvimento dos SO's que temos atualmente.

Em 1965, graças a “Digital Equipment Corp.”, surgiram os primeiros computadores de pequeno porte e baixo custo, eram os minicomputadores.

Em 1969, Ken Thompson, que havia trabalhado no MULTICS, começou a desenvolver seu próprio SO, que seria futuramente conhecido como Unix.

Década de 1970

Finalmente anos 70.

Nessa época, a LSI e a VLSI, foram os fatores que levaram adiante o processo de diminuir o tamanho e preço dos equipamentos eletrônicos. Assim, a Digital lança a sua nova linha de microcomputadores, o PDP-11 em 1970 e mais adiante o sistema VAX/VMS (Virtual Memory System) de 32 bits.

Em 1971, a Intel lança sue primeiro microprocessador, o “Intel 4004” e logo após o “Intel 8080”.

Em 1976, Steve Jobs e Steve Wozniak produzem o “Apple II” de 8 bits, que se tornou uma febre em todos os lugares. Assim consolidando a marca. E neste mesmo ano, a Apple e a Microsoft são fundadas.

Um problema que ainda tínhamos era a velocidade do processamento, assim a estratégia adotada foi a de criar máquinas com vários processadores, criando assim o multiprocessamento. E também foram criados processadores vetoriais e técnicas de paralelismo.

Nessa época surgiram as redes distribuídas (WAN's) e foram fortemente difundidas, com isso vários domínios foram criados, além de que surgiram também as primeiras LAN's. Assim, os SO's, se tornaram fortemente ligados aos softwares de rede.

E como uma última informação desta época, foi nela onde as linguagens que já devem ser conhecidas por você foram criadas. A Pascal e a C.

Arquitetura de Sistemas Operacionais #1

Thomas Lincoln — Tue, 23 Aug 2022 13:58:06 +0000

Hoje iremos ver a evolução dos sistemas operacionais, desde um pouco antes do seu surgimento até quase os tempos atuais.

Capítulo 1.4 do Livro Arquitetura de Sistemas Operacionais.

Então sem muita enrolação vamos lá (se ficar muito extenso irei dividir em dois posts).

Década de 1940

Infelizmente a nossa história começa em períodos de guerra, pois, caso você não saiba, muitos dos investimentos tecnológicos que foram o ponta pé inicial para os computadores, foram feitos por conta da guerra.

Com isso, criaram computadores, os primeiros, que eram máquinas gigantes com válvulas. Eram os computadores eletromecânicos. Sua função era a de fazer cálculos, assim como uma calculadora. Mas o que eles tinham de tamanho eles não tinham de velocidade.

Então simbora ver como eles surgiram.

Como já disse, o mundo se encontrava em guerra, e todas as máquinas eram feitas para ajudar na guerra. Assim, Alan Turing (que se você nunca ouviu falar, recomendo pesquisar sobre ele) desenvolveu o Enigma.

Essa coisinha fofa aqui em cima, foi a responsável por descriptografar mensagens alemãs. Assim sendo de excelente ajuda para os aliados. Além de ser o responsável por descriptografar a mensagem do dia D.

Em 1944, o primeiro computador eletromecânico foi criado (aquele das válvulas), o nome dele é Mark 1, ele foi muito utilizado para realizar cálculos matemáticos para a marinha. Um fato curioso é que as armaduras do homem de ferro são nomeadas com Mark (número da versão).

Logo após o Mark 1, em 1946 surge o ENIAC, foi o primeiro computador digital e eletrônico. Sua estrutura possuía 17 mil válvulas, 10 mil capacitores, 70 mil resistores e pesava em torno de 30 toneladas. Quando estava em funcionamento ele podia fazer cerca de 5 mil adições por segundo.

Um problema é que para operar ele os programadores precisavam de um profundo conhecimento do hardware dele, por conta de ser um computador que funciona a partir de hardware sem nenhum software. Além de que, para programar ele era preciso usar um painel com 6 mil conectores, usando linguagem de máquina.

A programação dele poderia levar dias, porém, se bem programado, cálculos antes feitos em 1 dia, poderiam ser feitos em segundos. E com esse avanço, o foco de melhoria não era mais no de velocidade de processamento, mas sim na velocidade de programação. Pois programar no ENIAC era custoso demais.

Nessa época, uma das pessoas responsáveis pelo desenvolvimento do ENIAC imaginou uma máquina onde os dados seriam armazenados em uma memória, tornando o processo de programação muito mais rápido, o que foi chamado de "programa armazenado" e essa é a base da arquitetura de computadores que temos hoje em dia.

O primeiro computador a utilizar esse sistema surgiu em 1949 seu nome era EDSAC, e logo após todas as máquinas criadas adotaram esse sistema. Nessa época ainda não tínhamos teclados, mouses ou telas, o uso do computador era voltado para área acadêmica e militar, e ainda não havia sinais do surgimento do primeiro SO.

Década de 1950

Com a chegada de uma nova década, os computadores com transistores e memórias magnéticas surgiram. Assim dando uma guinada na área tecnológica. Mesmo que computadores com transistores tenham sido criados no final da década passada, eles só foram lançados comercialmente apenas no final dos anos 50.

O transistor foi uma ferramenta que permitiu um aumento de velocidade no processamento e as fitas magnéticas permitiam um acesso mais rápidos aos dados e uma capacidade maior de armazenamento. Com isso os computadores se tornaram muito menores.

Nessa época, as grandes empresas da área surgiram. Sejam por serem criadas exclusivamente para computadores ou investindo na tecnologia. Entre elas estão: Raytheon, RCA, Burroughs e IBM, com o surgimento delas os computadores passaram a serem usados comercialmente.

Vamos lá ver como tudo isso aconteceu.

Em 1946, Eckert e Mauchly deixaram a universidade que estava, para formar a primeira empresa de computadores, seu nome era Eckert-Mauchly Computer Corp., o objetivo deles era criar o UNIVAC (Universal Automatic Computer). Porém, no caminho do desenvolvimento eles tiveram problemas financeiros, assim a emprea deles foi comprada pela Remington Rand Corp.,o que permitiu que eles pudessem terminar o projeto em 1951.

Assim o primeiro computador para fins comerciais nasceu, seu nome era UNIVAC I. Nessa mesma época o MIT colocou em cena o primeiro computador com processamento em tempo real.

Seu nome era Whirlwind I, o computador feito pelo MIT inovou em várias coisas, porém, a parte mais interessante era o uso de fitas magnéticas. Onde os programas (ou jobs), passaram a ser perfurados em cartões, que eram colocados em um equipamento de leitura e nesse equipamento os dados eram gravados em uma fita magnética.

Essa fita magnética era lida pelo processador, assim ele faria o cálculo, que executava o programa todo de uma vez e iria gravar o resultado em uma fita magnética para depois imprimir o resultado.

Porém ele executava apenas um programa por vez. Ou seja, o computador apenas lia, executava ou imprimia. Nomearam esse tipo de processamento de batch.

Pode parecer pouco, mas agora era possível adicionar vários programas na lista de espera, pois, anteriormente quando o computador estava executando um programa, não era possível fazer mais nada.

E nessa mesma época surgiram as linguagens de mais alto nível, o COBOL sendo uma delas. Assim, ter que lidar totalmente com a máquina deixou de ser uma necessidade, agora era possível começar a pensar na camada 1 do SO.

Nessa época também surgiu os SO's, que eram os responsáveis por agilizar processos custosos para o programador, que eram o de entrada e saída (Input/Output Control System - IOCS). Assim não era mais preciso desenvolver o seu código para leitura ou saída de dados.

Como um último evento desta época, a universidade de Manchester, desenvolveu o sistema ATLAS, que foi o precursor do sistema de memórias que temos hoje, com a sua memória hierarquizada. O que é extremamente essencial para a memória virtual, que eu já expliquei anteriormente.

E por hoje é isso, amanhã teremos os anos 60 e 70.

Arquitetura de Sistemas Operacionais #0

Thomas Lincoln — Sat, 20 Aug 2022 17:16:35 +0000

A partir deste post, eu irei destrinchar e explicar o que eu entendo do livro Arquitetura de Sistemas Operacionais do "Francies Berenger Machado" e o "Luiz de Paulo Maia". Desde o primeiro capítulo de uma forma mais geral. Resumindo de uma forma mais fácil de entender, porém, os posts seguirão o mesmo padrão dos meus posts anteriores.

Neste post, irei abordar do capítulo 1.1 até o 1.3.

O que é um SO?

Um Sistema Operacional, é nada mais nada menos que várias rotinas, que são executadas pelo processador da mesma forma que os programas. Porém, ele tem algumas diferenças, uma delas é que o SO é o responsável por possibilitar que o usuário possa usar seu computador sem ter que saber coisas como o computador e seus componentes físicos funcionem de maneira aprofundada. Assim, você pode jogar seu LoLzinho sem ter que programar a memória RAM rsrs.

Mas a grande diferença entre o SO e os demais programas, está em como ele é executado, não é como um programa que começa e termina. As rotinas do SO são constantemente chamadas, sempre que o usuário decide fazer algo que precisa de alguma rotina do SO, ela é chamada.

Com isso explicado, hora de ver as principais funções de um SO.

Funções de um SO

As funções do SO são resumidas em dois tópicos, a facilidade de acesso aos recursos do sistema e o compartilhamento de recursos de forma organizada e protegida.

Facilidade de Acesso aos Recursos do Sistema

Sempre que você usa o mouse, ou digita algo no seu teclado, ou vê algo na sua tela. Você faz isso sem se preocupar em como estabelecer uma conexão entre a CPU e cada um desses componentes, certo?

Pois bem, isso tudo é graças ao SO que faz essa conexão pra você, mas não se engane, isso não é nem um pouco simples, são inúmeras rotinas, só para o movimento do seu mouse modificar o movimento de uma setinha e mais rotinas ainda para que essa setinha aparece na tela e mais rotinas ainda para que essa seta se movimente na tela.

Funciona da Seguinte forma:

Compartilhamento de Recursos de Forma Organizada

E por último, mas não menos importante, o compartilhamento de recursos. Pense comigo, se o seu computador e o de outra pessoa estiverem conectados, o que aconteceria se no caminho o conteúdo da sua tela vá para a tela do seu amigo? Pois é, essa é a utilidade dessa função.

Porém, não é só para que não haja conflito em questões de computadores conectados. Pois, essa função também permite que seu computador seja multitarefa, assim você pode curtir sua música enquanto lê esse post.

Máquinas de Camadas

Antes da criação do SO, era necessário que qualquer programador tivesse aprofundados conhecimentos de hardware, assim tornando custoso e demorado se tornar um bom programador. Porém, assim que o SO surgiu, todo esforço se tornou muito menor, não sendo mais necessário ter um conhecimento da linguagem de máquina.

Com isso o computador começou a ter camadas ou níveis. As mais conhecidas são a do hardware (nível 0) a camada mais baixa e a que vem logo acima, a camada do software (nível 1). Porém, o número de camadas varia de acordo com as necessidades de cada usuário. Uma das vantagens disso, é que quando o usuário está trabalhando em uma camada, ele não precisa se preocupar com as demais camadas.

Atualmente as camadas dos computadores são feitas da seguinte forma:

Memória Real x Memória Virtual e Fragmentação

Thomas Lincoln — Wed, 17 Aug 2022 14:57:15 +0000

Assim como já vimos em posts anteriores, a memória vê uma lista de endereços que apontam para páginas e não necessariamente temos o número máximo de endereços que a CPU nos fornece, onde o barramento nos limita e o SO reserva um pouco para ele.

Porém, temos um outro detalhe que é importante saber e entender. Que é a memória virtual.

Mas o que é isso Thomas?

Então, na memória real, nós realmente tínhamos uma lista de endereços que iam por exemplo de 000 até FFF (desconsiderando todas as diminuições apenas para que seja mais fácil de entender). Porém isso causava um problema onde os programas podiam acessar os dados um dos outros e outros problemas. Com isso, a partir dos anos 90, surgiram processadores capazes de usar memória virtual.

O que acontece?

Bem, a memória virtual funciona da seguinte forma, ela pega uma parte da memória local e cria endereços virtuais, assim o programa vai ver uma memória de 000 até FFF, mas na vdd vai estar acessando por exemplo A43. E conforme for precisando de mais ele vai alocando.

E com isso os programas começa a se tornar isolados. Impedindo que eles comecem a acessar dados um dos outros.

Fragmentação

Como um último assunto desse post vou falar sobre fragmentação. Vamos supor que você tenha 5 caixinhas, e sempre que você quiser armazenar coisas nela tenha que ser em caixas seguidas.

(Você vai precisar de bastante imaginação)

Suponha que você guarde 3 tênis nas primeiras caixas. E agora decida guardar 2 camisetas nas duas últimas. Mas agora decide esvaziar a segunda e a quarta caixa.

E agora vc tem duas caixas vazias, mas separadas. E como você só pode salvar coisas contínuas, mesmo que possa guardar duas coisas, você só pode guardar coisas diferentes. E esse é o problema da fragmentação.

Como a memória funciona?

Thomas Lincoln — Tue, 16 Aug 2022 14:57:38 +0000

Como já vimos anteriormente, o computador funciona com vários tipos de memória, algumas voláteis e outras não. Como a memória secundária, a principal ou a cache. O sistema Operacional é o responsável por organizar essa bagunça toda de memórias, dizendo onde cada dado ou operação vai.

Mas antes de entender como o computador organiza a memória, nós precisamos entender como o programa vê a memória, quando é executado ou quando ele está armazenado, ele não identifica "ah, olha só uma memória RAM que daora" ou "ah, aquele lá é o HD, gente fina ele".

Ele apenas vê memória, a CPU é a responsável por dizer onde vai o que, e é nela que fica a memória cache, com os barramentos que conectam ela as memórias RAM, HDs, etc.

Como o computador vê a memória?

Vamos lá, seria uma enrolação sem fim explicar a fundo, falar dos Flip-Flops e tudo mais. Então vou usar a analogia que o nosso querido "Fábio Akita" usou no seu vídeo sobre gerenciamento de memória, créditos para ele e fica o link para o vídeo dele (https://www.youtube.com/watch?v=9AK_1gqEfkQ)

Enfim, créditos dados, vamos lá para a explicação.

Podemos entender a memória RAM como um livro com um índice, com várias linhas de "endereços", onde cada uma aponta para uma página de informações(dados).

Essas linhas, são os nossos endereços (ponteiros pra quem já estudou estrutura de dados). O tamanho desses endereços depende da arquitetura da máquina, máquinas de 64 bits suportam 2^64 bits, assim o tamanho seria: 18.446.744.073.709.551.616. Porém, o computador lê em binário, então o maior seria 1111111111111111111111111111111111111111111111111111111111111111.

Calma, ainda fica melhor, mas primeiro, você não precisa decorar esses valores. Agora vamos descobrir uma forma de melhorar mais ainda isso dai.

Como você deve ter percebido, ficou um valor monstruoso, porém, uma coisa que frequentemente faziam era dividir esses dados em grupos, as vezes em grupos de 8, ou as vezes em grupos de 16. E é ai que entra o nosso sistema novo, pois queríamos representar esses 16 valores, mas só com o sistema arábico não era possível, pois só ia do 0 ao 9, então acrescentamos mais 6 letras, A até F.

Assim, aquele numero gigante, virou FFFF FFFF FFFF FFFF

Tcharam.

Assim, o nosso índice é visto com endereços de 0000... até FFFF...

Fica a curiosidade, em sistemas 32 bits, nós tínhamos 2^32, o que resultava em 4gb de endereços, o que fazia com que sistemas 32 bits não suportassem mais do que 4gb. E por isso muitos dos seus jogos antigos precisam de um patch

Temos acesso aos 64 bits de endereço?

Uma coisa que você precisa saber sobre esse assunto, antes que você vá embora ver outro post, é preciso você saber que mesmo que seu computador seja 64 bits, você não terá acesso a esses 64, pois, o barramento que conecta o CPU às memórias, limita isso.

Então saiba, você pode ter um computador 64 bits, mas dependendo do seu CPU, você terá menos que isso.