O que é ReactJS?

Se você já navegou por uma aplicação web moderna e interativa, é bem provável que tenha experimentado o poder do ReactJS, uma das bibliotecas JavaScript mais populares do mundo.

Desenvolvido pelo Facebook, o React revolucionou a forma como desenvolvedores constroem interfaces de usuário (UIs), graças à sua abordagem baseada em componentes, uso do Virtual DOM e foco em desempenho.

Neste artigo, você vai entender o que é o ReactJS, como ele surgiu, quais são suas principais características, vantagens e desvantagens — e ainda vai aprender a dar os primeiros passos com um exemplo prático. Se você está iniciando no desenvolvimento front-end ou buscando se atualizar com as ferramentas mais modernas do mercado, este guia é para você.

1 – O que é ReactJS?

ReactJS (frequentemente chamado apenas de React) é uma biblioteca JavaScript de código aberto para a construção de interfaces de usuário (UIs) interativas e reativas. Desenvolvida pelo Facebook, ela se destaca por seu foco na componentização e na criação de aplicações de página única (SPAs) eficientes e responsivas. Em vez de manipular diretamente o DOM (Document Object Model) do navegador, o React introduz um conceito inovador: o Virtual DOM, que otimiza drasticamente o desempenho das aplicações.

1.1 – Como o ReactJS surgiu?

O React foi criado por Jordan Walke, um engenheiro de software do Facebook, em 2011. Sua motivação inicial foi resolver os desafios de manutenção e escalabilidade enfrentados pelas interfaces de usuário complexas do Facebook, especialmente no news feed. A arquitetura tradicional de manipulação do DOM estava se tornando um gargalo, e a necessidade de uma abordagem mais eficiente e declarativa era evidente.

Inicialmente chamado de “FaxJS”, o React foi introduzido publicamente em 2013, durante a conferência JSConf US. Desde então, sua adoção cresceu exponencialmente, impulsionada pela sua eficácia na construção de UIs complexas e pela forte comunidade que se formou ao seu redor.

2 – As principais características do React

O React se destaca por diversas características que o tornam uma escolha poderosa para o desenvolvimento front-end:

  • Baseado em Componentes: o coração do React são os componentes. Uma interface de usuário é dividida em pequenas partes isoladas e reutilizáveis, como botões, barras de navegação ou cartões de produto. Cada componente possui sua própria lógica e aparência, o que facilita a organização, manutenção e reusabilidade do código.
  • Virtual DOM: em vez de fazer atualizações diretas no DOM real do navegador (as quais são custosas), o React cria uma cópia leve desse DOM em memória, chamada de Virtual DOM. Quando o estado de um componente muda, o React compara o Virtual DOM atual com o anterior e calcula a forma mais eficiente de atualizar apenas as partes que realmente mudaram no DOM real. Isso resulta em um desempenho superior.
  • Abordagem Declarativa: no React, você descreve como a UI deve se parecer para um determinado estado. E o React se encarrega de renderizá-la e mantê-la atualizada. Isso contrasta com a abordagem imperativa, onde você dita passo a passo como manipular o DOM. A abordagem declarativa torna o código mais previsível e fácil de depurar.
  • JSX: o JSX (JavaScript XML) é uma extensão de sintaxe para JavaScript que permite escrever código HTML dentro do JavaScript. Embora não seja obrigatório, o JSX é amplamente utilizado no React por tornar a criação de componentes mais intuitiva e legível, misturando a lógica JavaScript com a estrutura da interface.
  • Fluxo de Dados Unidirecional (One-Way Data Binding): o React segue um fluxo de dados unidirecional, onde os dados fluem de componentes pais para componentes filhos através de props (propriedades). Isso simplifica o rastreamento e a depuração do estado da aplicação, tornando-a mais previsível.

2.1 – Vantagens e desvantagens

Como qualquer tecnologia, o React possui seus pontos fortes e fracos. Vamos ver uma lista de vantagens e desvantagens dessa biblioteca, começando pelas vantagens:

  • Eficiência e Desempenho: graças ao Virtual DOM, o React otimiza as atualizações da UI, resultando em aplicações rápidas e responsivas.
  • Reusabilidade de Componentes: a arquitetura baseada em componentes promove a modularidade e reusabilidade do código, acelerando o processo de desenvolvimento e reduzindo a duplicação de códigos.
  • Grande Comunidade e Ecossistema: o React possui uma das maiores e mais ativas comunidades de desenvolvedores, o que significa vasta documentação, tutoriais, bibliotecas de terceiros e suporte constante.
  • Curva de Aprendizagem Moderada (para o básico): embora existam conceitos avançados, os fundamentos do React (componentes, props, estados) são relativamente fáceis de assimilar, especialmente para quem já tem algum conhecimento em JavaScript.
  • Flexibilidade: o React é uma biblioteca, não um framework. Dessa forma, ele oferece flexibilidade para escolher outras bibliotecas e ferramentas (como roteadores, gerenciadores de estado, etc.) que melhor se adaptem às necessidades do seu projeto.

Mas, como não existe nenhuma ferramenta perfeita, ao conhecer o React é importante levar em conta algumas pequenas desvantagens dessa bilbioteca:

  • Biblioteca, Não Framework: em alguns casos, a flexibilidade pode ser uma desvantagem para iniciantes, que podem se sentir perdidos com a quantidade de escolhas de ferramentas e bibliotecas complementares. Um framework oferece uma estrutura mais “opiniosa”.
  • JSX pode ser um Obstáculo Inicial: para quem nunca teve contato, a sintaxe JSX pode parecer estranha no início, aumentando a curva de aprendizagem da ferramenta.
  • Grande Velocidade de Mudanças: o ecossistema React evolui rapidamente, com novas ferramentas e abordagens surgindo frequentemente. Nesse cenário, manter-se atualizado pode ser um grande desafio.
  • SEO para SPAs: embora tenha melhorado muito, as Single Page Applications (SPAs) construídas com React podem apresentar desafios iniciais de SEO se não forem configuradas corretamente para renderização no lado do servidor (SSR) ou pré-renderização.

3 – Como instalar o React?

Para começar a desenvolver com React, você precisará ter o Node.js e o npm (Node Package Manager) ou Yarn instalados em sua máquina. Se você ainda não tem o Node.js em sua máquina, clique aqui para conhecer mais sobre esse ambiente de execução JavaScript e para aprender a como instalá-lo.

A maneira mais comum e recomendada de iniciar um novo projeto React é usando o Create React App. Para instalar o Create React App e criar um novo projeto, abra o terminal de sua IDE (ou do seu sistema operacional) e execute os seguintes comandos:

npx create-react-app contador-de-cliques-react
cd contador-de-cliques-react
npm start

npx create-react-app meu-primeiro-app-react: este comando utiliza o npx (que executa pacotes npm sem a necessidade de instalá-los globalmente) para baixar e executar o create-react-app. Ele criará uma nova pasta com o nome meu-primeiro-app-react contendo toda a estrutura inicial do seu projeto React.

cd meu-primeiro-app-react: navega para o diretório do seu novo projeto.

npm start: inicia o servidor de desenvolvimento do React, que abrirá automaticamente seu aplicativo no navegador (geralmente em http://localhost:3000).

Você perceberá que seu projeto terá uma estrutura idêntica a essa aqui:

Estrutura inicial do contador de cliques.

E se você acessar http://localhost:3000 (ou o endereço que você definiu para subir a aplicação), verá uma tela semelhante a essa aqui:

Página de exemplo inicial de projetos React.

Por enquanto, vamos manter nosso projeto assim. Nos tópicos a seguir vamos construir um exemplo prático e didático com React. Mas antes disso, vamos ver dois pontos muito importantes:

3.1 – IDEs para desenvolver em React

Uma IDE (Ambiente de Desenvolvimento Integrado) ou um editor de código bem otimizado é uma ferramenta crucial para garantir uma boa produtividade e tornar o processo de desenvolvimento mais agradável. Essas ferramentas oferecem recursos como realce de sintaxe, autocompletar inteligente, depuração integrada e suporte a extensões que facilitam muito a escrita de código React.

Embora, em teoria, você possa usar qualquer editor de texto, algumas ferramentas se destacam pelo seu suporte robusto a JavaScript e React. As mais populares e recomendadas pela comunidade são:

  • Visual Studio Code (VS Code): de longe a escolha mais popular, o VS Code é um editor de código leve, mas extremamente poderoso, desenvolvido pela Microsoft. Ele possui um vasto ecossistema de extensões que transformam-no em uma IDE completa para desenvolvimento React, com funcionalidades como IntelliSense, depuração de código, integração com Git e muito mais. É uma excelente opção tanto para iniciantes quanto para desenvolvedores experientes.
  • WebStorm: desenvolvido pela JetBrains, o WebStorm é uma IDE JavaScript mais robusta. Ele oferece uma integração mais profunda com as tecnologias front-end, proporcionando recursos avançados de refatoração, análise de código e depuração, além de um suporte excepcional para React. É ideal para quem busca uma experiência de desenvolvimento mais completa e profissional.
  • Sublime Text: um editor de texto rápido, leve e elegante. Conhecido por sua alta performance, embora seja menos completo que as opções anteriores por padrão, ele pode ser estendido com pacotes e plugins para dar suporte ao desenvolvimento React.

É importante frisar que, além dessas opções, há muitas outras disponíveis no mercado. A escolha da IDE é pessoal e depende das suas preferências e necessidades. No entanto, eu recomendo o VS Code, pois ele é amplamente recomendado por sua flexibilidade, leveza, ampla gama de extensões e, além de tudo isso, é gratuito.

3.2 – Documentação oficial

A documentação oficial do React é um recurso inestimável para qualquer desenvolvedor, seja ele iniciante ou experiente. Ela é constantemente atualizada, abrangente e fornece guias detalhados, exemplos de código e explicações claras sobre todos os conceitos do React.

Você pode acessá-la em: https://react.dev/

É altamente recomendável consultá-la sempre que tiver dúvidas ou quiser aprofundar seus conhecimentos em algum tópico específico.

4 – Exemplo prático: um componente de contador simples

Vamos criar um simples componente de contagem de cliques para ilustrar os conceitos de estado e JSX no React.

No projeto em que criamos no item 3, vamos criar um novo diretório chamado contador e dentro dele vamos criar dois novos arquivos: contador.jsx e contador.css. Sua estrutura ficará assim:

Estrutura atualizada do contador de cliques com a pasta contador.

Agora, você vai inserir os códigos abaixo em seus respectivos arquivos. Para um melhor entendimento, lembre-se a função de cada arquivo:

contador.jsx: é o componente do contador de cliques em si.
contador.css: é o componente que contém a estilização do contador.
App.js: é o componente principal, onde a estrutura inicial da aplicação é definida e outros componentes são renderizados.

contador.jsxcontador.cssApp.js

import { useState } from 'react'; // Importa o hook useState do React
import './contador.css' // Importa a folha de estilos do componente

export default function Contador() {
  // Declara uma variável de estado 'count' e uma função 'setCount' para atualizá-la
  // O valor inicial de 'count' é 0
  const [count, setCount] = useState(0);

  // Função para incrementar o contador
  const incrementar = () => {
    setCount(count + 1);
  };

  // Função para decrementar o contador
  const decrementar = () => {
    setCount(count - 1);
  };

  return (
    <div className='container'>
      <h1> Contador React</h1>
      <p> Valor atual: {count}</p> {/* Exibe o valor do estado */}
      <button> onClick={incrementar}>+ Incrementar</button> {/* Botão para incrementar */}
      <button onClick={decrementar}>- Decrementar</button> {/* Botão para decrementar */}
    </div>
  );
}

body {
  margin: 0;
  padding: 0;
  font-family: Arial, sans-serif;
  background-color: #f2f2f2;
}

.container {
  display: flex;
  flex-direction: column;
  align-items: center;
  justify-content: center;
  height: 100vh;
}

h1 {
  color: #333;
}

p {
  font-size: 1.5rem;
  margin: 20px 0;
}

button {
  background-color: #4CAF50;
  color: white;
  border: none;
  padding: 12px 20px;
  margin: 5px;
  font-size: 1rem;
  border-radius: 6px;
  cursor: pointer;
  transition: background-color 0.3s ease;
}

button:hover {
  background-color: #45a049;
}

import './App.css';
import Contador from './contador/contador';

function App() {
  return (
    <Contador/>
  );
}

export default App;

Ao aplicar esses códigos você chegará em um resultado idêntico a esse aqui:

Demonstração do contador de cliques em funcionamento.

Veja que, apesar de simples, o contador de cliques já nos traz uma boa introdução de como o React funciona. Ao utilizar essa biblioteca podemos ir muito mais longe, criando aplicações robustas e altamente escaláveis. Não deixe de pesquisar e se aprofundar nessa ferramenta amplamente popular no desenvolvimento front-end.

Conclusão

O ReactJS é uma das bibliotecas JavaScript mais populares que existe e possui um ecossistema completo que transformou a forma como criamos aplicações web.

Com sua arquitetura baseada em componentes reutilizáveis, atualização eficiente via Virtual DOM e uma comunidade extremamente ativa, ele oferece uma base sólida para o desenvolvimento de interfaces modernas, escaláveis e de alta performance.

Neste artigo, você teve uma introdução completa ao React, aprendeu a configurá-lo, explorou suas principais vantagens e ainda desenvolveu um componente simples. Agora é hora de ir além: explore a documentação oficial, teste outros componentes e aprofunde-se nas ferramentas que tornam o React ainda mais poderoso.

Espero que este conteúdo seja útil em sua trajetória! Se você gostou do conteúdo, compartilhe com seus amigos e aproveite para conhecer mais sobre programação aqui!

O que é GraphQL?

Na área de desenvolvimento de software, a comunicação entre aplicações front-end e serviços back-end é um tema essencial. Tradicionalmente, as APIs REST (Representational State Transfer) têm sido o padrão de mercado para essa interação. No entanto, uma alternativa poderosa tem ganhado cada vez mais destaque: o GraphQL.

Criado pelo Facebook em 2012 e liberado como código aberto em 2015, o GraphQL é uma linguagem de consulta que propõe uma abordagem diferente das APIs REST tradicionais, permitindo que o cliente especifique exatamente quais dados precisa obter, recebendo uma resposta estruturada e de acordo com essa especificação.

Neste artigo vamos conhecer o que é o GraphQL, como surgiu, quais suas principais características, entre outros temas. Vamos começar?

1. O que é GraphQL?

GraphQL é uma linguagem de consulta (query language) para APIs e um conjunto de ferramentas de tempo de execução (runtime) para executar essas consultas com base nos seus dados.

Ao invés de ter múltiplos endpoints REST, onde cada um retorna um conjunto fixo de dados, com o GraphQL você tem um único endpoint que permite ao cliente solicitar exatamente os dados que precisa. Isso simplifica a interação entre cliente e servidor, bem como evita a sobrecarga de rede.

Pense na seguinte analogia: em uma API REST, é como se você fosse a um restaurante e tivesse que pedir um prato “combo” que vem com hambúrguer, batata frita e refrigerante, mesmo que só queira o hambúrguer. Já com o GraphQL, você pode pedir apenas o hambúrguer, e o garçom (o servidor) vai te trazer somente isso. Isso evita o chamado “over-fetching” (buscar mais dados do que o necessário) e o “under-fetching” (buscar dados insuficientes, exigindo múltiplas requisições).

O GraphQL é composto, basicamente, por três partes principais:

  • Linguagem de Consulta: define como o cliente busca pelos dados.
  • Esquema (Schema): especifica quais tipos de dados estão disponíveis na API e como eles se relacionam.
  • Resolução (Resolvers): funções que atendem às consultas, buscando os dados no back-end.

1.1. Como o GraphQL surgiu?

O GraphQL foi desenvolvido pelo Facebook em 2012 e lançado publicamente em 2015. A necessidade surgiu da complexidade crescente de seus aplicativos (web, mobile, dispositivos IoT etc.), os quais precisavam de uma maneira mais eficiente de buscar dados em seus servidores. As APIs REST do Facebook estavam gerando problemas de desempenho e lentidão no desenvolvimento de novos recursos, pois as equipes de front-end e back-end precisavam coordenar cada mudança em vários endpoints.

A solução encontrada foi a criação de uma nova abordagem onde o front-end tivesse mais controle sobre a estrutura dos dados retornados. Isso permitiu que o Facebook criasse uma API unificada que alimentasse tanto seu aplicativo móvel quanto a versão web, reduzindo a necessidade de endpoints específicos para cada plataforma e otimizando a velocidade de desenvolvimento.

2 – Principais características do GraphQL

Para entender como o GraphQL funciona, é crucial conhecer alguns termos-chave:

  • Schema: o schema define as operações disponíveis (queries, mutations e subscriptions) e os tipos de dados que podem ser consultados (object types, scalar types, enums, interfaces, etc.). Essencialmente, o schema é um contrato entre o front-end e o back-end, especificando os tipos de dados, os campos disponíveis e as relações entre eles. Os schemas são escritos em uma Linguagem de Definição de Schema (SDL).
  • Queries: são operações de leitura de dados que o cliente executa. Nelas, o desenvolvedor define quais campos o cliente pode consultar, aninhando objetos conforme a necessidade daquela operação.
  • Mutations: são operações de escrita ou modificação de dados (criação, atualização e exclusão). São semelhantes às queries, porém voltadas para alteração de estado no servidor. Uma observação é que, ao contrário das queries, que podem ser executadas em paralelo, as mutations são executadas em série para garantir a integridade dos dados.
  • Resolvers: são funções do lado do servidor que resolvem uma query ou mutation e retornam os dados para cada campo do schema. Podem acessar bancos de dados, serviços externos ou qualquer outra fonte de informação. Importante ressaltar que cada campo no schema possui um resolver correspondente.
  • Subscriptions: mecanismo para notificações em tempo real, mantendo uma conexão WebSocket ou similar para enviar atualizações ao cliente.
  • Tipos Comuns: o GraphQL é fortemente tipado. Isso significa que todos os campos e tipos de dados no schema têm um tipo definido (como String, Int, Boolean, etc.). Essa tipagem forte garante que a aplicação seja mais robusta e que os erros sejam identificados mais cedo, durante o desenvolvimento.
    • Scalars: Int, Float, String, Boolean, ID.
    • Object Types: definem objetos com campos específicos.
    • Lists e Non-Null: definem coleções e campos obrigatórios, respectivamente.
    • Enums, Interfaces e Unions: permitem modelar estruturas mais complexas e polimorfas.

3 – As vantagens e desvantagens do GraphQL

Como toda tecnologia, o GraphQL também tem seus prós e contras, os quais precisam ser avaliados antes da sua adoção.

3.1 – Vantagens:

  • Eficiência e Desempenho: permite buscar exatamente o que é necessário, reduzindo a quantidade de dados transferidos e o número de requisições de rede. Dessa forma, o cliente recebe apenas os dados necessários, evitando overfetching e underfetching.
  • Desenvolvimento Ágil e Flexível: o front-end se torna mais independente do back-end. A equipe de front-end pode solicitar novos dados sem a necessidade da equipe do back-end criar ou modificar um novo endpoint. Isso acelera o processo de desenvolvimento.
  • Documentação e Tipagem Automática: o schema atua como uma documentação viva da API. Ferramentas como o GraphiQL (um ambiente de desenvolvimento para GraphQL) usam o schema para fornecer autocompletar e validação de consultas, facilitando a vida do desenvolvedor.
  • Uma única requisição: em muitas situações, o GraphQL permite que o cliente obtenha todos os dados que precisa em uma única requisição, evitando o problema de “cascata de requisições” comum em APIs REST.

3.2 – Desvantagens:

  • Complexidade e Curva de Aprendizagem: a curva de aprendizado inicial é maior, especialmente para desenvolvedores acostumados apenas com REST.
  • Cache: o cache é mais desafiador de implementar no GraphQL do que em APIs REST. A ausência de endpoints distintos dificulta o cache HTTP tradicional. No entanto, existem soluções e bibliotecas para lidar com isso.
  • Upload de Arquivos: o upload de arquivos binários pode ser mais complexo de lidar em GraphQL.
  • Monitoramento e Limitação de Taxa (Rate Limiting): a implementação de rate limiting e monitoramento em um único endpoint pode ser mais desafiadora do que em múltiplos endpoints REST. Assim, se faz necessário, criar lógicas de negócio mais sofisticadas para controlar o acesso.

4 – Exemplo prático

A seguir, para fins de um melhor entendimento, vamos ver um exemplo simples de implementação de GraphQL usando Node.js e Apollo Server.

4.1 – Configurando o ambiente

Para começar vamos criar uma pasta chamada graphql-books-api e executar os comandos abaixo via terminal em seu respectivo diretório:

npm init -y
npm pkg set type="module"
npm install apollo-server graphql
npm install --save-dev nodemon

Após executar esses comandos, será criada uma pasta chamada node_modules e dois arquivos: package.json e package-lock.json.

Em seu arquivo package.json, você precisará inserir as informações do script de desenvolvimento, no respectivo trecho de “scripts”:

{
  "name": "graphql-books-api",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "start": "node index.js",
    "dev": "nodemon index.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "type": "module",
  "dependencies": {
    "apollo-server": "^3.13.0",
    "graphql": "^16.11.0"
  },
  "devDependencies": {
    "nodemon": "^3.1.10"
  }
}

Pronto! Nosso ambiente Node.js já possui uma configuração básica para iniciar o desenvolvimento. Agora, vamos acrescentar duas pastas nessa estrutura (schema e resolvers) e três arquivos (schema.js, resolvers.js e index.js), chegando a esse resultado:

Diretório do projeto exemplo de GraphQL

4.2 – Criando nosso serviço GraphQL

Com o ambiente criado e configurado, vamos inserir os códigos JavaScript de cada um desse nossos arquivos e na sequência vamos executar o servidor e testar a API:

index.jsschema.jsresolvers.js

import { ApolloServer } from 'apollo-server';
import typeDefs from './schema/schema.js';
import resolvers from './resolvers/resolvers.js';

const server = new ApolloServer({ typeDefs, resolvers });

server.listen({ port: 4000 }).then(({ url }) => {
  console.log(`🚀 Server ready at ${url}`);
});

import { gql } from 'apollo-server';

const typeDefs = gql`
  type Book {
    id: ID!
    title: String!
    author: String!
  }

  type Query {
    books: [Book!]!
    book(id: ID!): Book
  }

  type Mutation {
    addBook(title: String!, author: String!): Book!
  }
`;

export default typeDefs;

const books = new Map();

// Dados iniciais (mock realizado para fins de teste)
books.set("1", { id: "1", title: "Clean Code", author: "Robert C. Martin" });
books.set("2", { id: "2", title: "1984", author: "George Orwell" });

const resolvers = {
  Query: {
    books: () => Array.from(books.values()),
    book: (_, { id }) => books.get(id),
  },
  Mutation: {
    addBook: (_, { title, author }) => {
      const id = String(books.size + 1);
      const newBook = { id, title, author };
      books.set(id, newBook);
      return newBook;
    },
  },
};

export default resolvers;

Após inserir os códigos, no terminal execute o comando abaixo para iniciar o servidor Node.js:

npm run dev

Se tudo estiver certo, você visualizará essa mensagem:

🚀 Server ready at http://localhost:4000/

Com o servidor iniciado, vamos testar nossa API. Abra o navegador e acesse http://localhost:4000. Na tela que vai carregar clique em “Query your server” e execute essa query de exemplo:

query {
  books {
    id
    title
    author
   }
}

O resultado dessa query será um arquivo em formato Json com os livros que fizemos mock em nossa API de GraphQL.

Vamos testar também um mutation para adicionarmos um livro:

mutation {
  addBook(title: "O Hobbit", author: "J.R.R. Tolkien") {
     id
     title
     author
   }
}

Você terá um retorno mostrando o registro inserido no seu mock. Se executar a query de consulta novamente, o novo livro registrado aparecerá no seu retorno.

A partir desse exemplo prático veja como é simples dar os seus primeiros passos com GraphQL usando Node.js e Apollo Server. A partir desse ponto, você pode explorar recursos mais avançados, integrar com bancos de dados reais e desenvolver APIs robustas para diferentes tipos de aplicações. E não se esqueça, o GraphQL não é compatível apenas com Node.js, você pode utilizá-lo com outras linguagens de sua preferência como PHP, Python e Java, entre outras.

Conclusão

O GraphQL surge como uma alternativa moderna e eficiente às APIs REST, oferecendo maior flexibilidade e controle sobre as requisições de dados feitas pelo cliente. Ao permitir que o front-end especifique exatamente o que precisa, ele elimina a necessidade de múltiplos endpoints, reduz o tráfego de dados e acelera o desenvolvimento de aplicações mais dinâmicas e escaláveis.

Apesar de exigir uma curva de aprendizado inicial maior e apresentar alguns desafios técnicos — como cache e upload de arquivos —, o GraphQL tem se mostrado uma poderosa ferramenta para quem busca criar APIs mais intuitivas, documentadas e alinhadas com as necessidades reais do cliente.

Seja você um desenvolvedor front-end buscando maior autonomia ou um desenvolvedor back-end em busca de soluções mais eficientes, vale a pena considerar o GraphQL como parte do seu stack de desenvolvimento.

Espero que este conteúdo seja útil em sua trajetória! Se você gostou do conteúdo, compartilhe com seus amigos e aproveite para conhecer mais sobre APIs e outros assuntos de tecnologia da informação aqui!

O que é inteligência artificial?

Nos últimos anos, o termo inteligência artificial (IA) tomou conta da mídia e passou a fazer parte do vocabulário cotidiano de todo mundo. Presente em áreas que vão da saúde à indústria, da educação ao entretenimento, a Inteligência Artificial é um ramo da ciência da computação cujo objetivo é automatizar tarefas e aumentar a eficiência, precisão e produtividade na sua execução.

Para alcançar esse objetivo, sistemas de inteligência artificial procuram simular capacidades humanas, como raciocínio, aprendizado, percepção e tomada de decisões. Em outras palavras, algoritmos de inteligência artificial são modelos computacionais que permitem às máquinas executarem tarefas que, tradicionalmente, exigiriam inteligência humana.

Mas afinal, o que realmente é uma inteligência artificial? Como ela surgiu? Quais as principais ferramentas e chatbots da atualidade? Neste artigo, vamos responder a essas e outras perguntas. Vamos começar?

1 – O que é Inteligência Artificial?

Em essência, a Inteligência Artificial é um campo da ciência da computação que se dedica ao estudos e à criação de máquinas capazes de simular a inteligência humana. Isso envolve capacitá-las a aprender, raciocinar, resolver problemas, perceber contextos e entender a linguagem utilizada na comunicação. O objetivo principal da IA não é necessariamente substituir o cérebro humano, mas sim aprimorar nossas capacidades. O uso da IA permite automatizar tarefas complexas e descobrir padrões que seriam invisíveis para nós.

Para uma máquina ser considerada “inteligente”, ela precisa cumprir alguns requisitos como: processar grandes volumes de dados, identificar relações, tomar decisões baseadas nesses dados e melhorar seu desempenho ao longo do tempo, sem ser explicitamente programada para cada cenário.

1.1 – Como surgiram as primeiras Inteligências Artificiais?

Por mais surpreendente que possa parecer, a ideia de máquinas pensantes não é nova e remonta a séculos, com mitos e ficção científica. No entanto, o nascimento formal da Inteligência Artificial como campo de estudo é geralmente atribuído à Conferência de Dartmouth em 1956.

Foi nesse evento que o termo “Inteligência Artificial” foi cunhado por John McCarthy e onde pesquisadores proeminentes se reuniram para discutir a possibilidade de construir máquinas que poderiam “aprender e pensar”.

Nos anos que se seguiram, a IA passou por períodos de grande otimismo, seguidos por “invernos da IA”, onde o financiamento e o interesse diminuíram devido às limitações tecnológicas da época. No entanto, os avanços na capacidade de processamento dos computadores e o desenvolvimento de algoritmos mais sofisticados para tratar grandes volumes de dados (Big Data) pavimentaram o caminho para o renascimento da IA, nos conduzindo ao cenário que vivenciamos hoje.

2 – Tipos de IAs

As Inteligências Artificiais podem ser classificadas de várias formas, mas uma das mais comuns é a divisão em IA Fraca e IA Forte:

  • IA Fraca (ou IA Estreita/Limitada): são as IAs que hoje vemos em praticamente todas as aplicações. Ela é projetada e treinada para executar uma tarefa específica e bem definida. Exemplos incluem assistentes de voz (Siri, Alexa), chatbots (ChatGPT, Gemini), sistemas de condução de carros autônomos ou softwares de reconhecimento facial. Esses sistemas não possuem consciência nem inteligência geral, apenas executam sua função designada.
  • IA Forte (ou IA Geral/Completa): é o tipo de IA que se equipararia à inteligência humana em todos os aspectos, sendo capaz de entender, aprender e aplicar sua inteligência para resolver qualquer problema, assim como um ser humano. Atualmente, a IA forte permanece no campo da teoria e da ficção científica, sem que tenhamos atingido esse nível de desenvolvimento.

3 – Técnicas de aprendizado de máquina

Dentro do campo da IA, o Aprendizado de Máquina (Machine Learning – ML) é uma das áreas mais cruciais. É através dele que as máquinas adquirem a capacidade de aprender a partir dos dados. As principais técnicas incluem:

  • Aprendizado Supervisionado: a máquina é treinada com um conjunto de dados que já possui “respostas” (rótulos). Por exemplo, você alimenta o algoritmo com fotos de cães e gatos, e para cada foto, informa se é um cão ou um gato. Com o tempo, ele aprende a distinguir os dois por conta própria. É ideal para tarefas de classificação e regressão.
  • Aprendizado Não Supervisionado: neste caso, o algoritmo recebe dados sem rótulos e precisa encontrar padrões, estruturas ou agrupamentos por sua conta. É útil para identificar segmentos de clientes ou detectar anomalias em grandes conjuntos de dados.
  • Aprendizado por Reforço: a máquina aprende através de tentativa e erro, interagindo com um ambiente e recebendo “recompensas” ou “penalidades” por suas ações. É a base para o desenvolvimento de sistemas de jogos e robótica, onde o objetivo é otimizar o comportamento para maximizar as recompensas.
  • Deep Learning (Aprendizado Profundo): uma sub-área do Machine Learning que utiliza redes neurais artificiais com múltiplas camadas (por isso “profundo”) para modelar e processar dados de forma mais complexa. O Deep Learning é responsável por avanços notáveis em reconhecimento de voz, processamento de linguagem natural e visão computacional.

4 – Ferramentas de IA

O ecossistema de ferramentas de IA cresce exponencialmente dia a dia. Empresas e desenvolvedores contam com uma vasta gama de recursos para construir e implementar suas soluções. Algumas das mais proeminentes incluem:

4.1 – Principais ferramentas de IA na atualidade

  • TensorFlow (Google): uma das bibliotecas de código aberto mais populares para desenvolvimento de modelos de Machine Learning e Deep Learning. Amplamente utilizada para pesquisa e produção.
  • PyTorch (Meta/Facebook): outra biblioteca de código aberto muito utilizada para Deep Learning, conhecida por sua flexibilidade e facilidade de uso, especialmente para prototipagem rápida.
  • Scikit-learn: uma biblioteca Python versátil que oferece uma vasta gama de algoritmos de Machine Learning para tarefas como classificação, regressão, agrupamento e pré-processamento de dados.
  • Microsoft Azure AI: uma plataforma de serviços de IA baseada na nuvem que oferece APIs e ferramentas para integrar recursos de IA (visão computacional, processamento de linguagem natural, machine learning) em aplicações.
  • Amazon Web Services (AWS AI/ML): assim como o Azure, a AWS oferece um conjunto abrangente de serviços de IA e Machine Learning na nuvem, permitindo que desenvolvedores criem e implementem soluções de IA de forma escalável.
  • Google Cloud AI Platform: outra opção de plataforma de nuvem robusta com uma vasta gama de ferramentas e serviços para desenvolvimento e implantação de IA, desde modelos pré-treinados até ferramentas personalizáveis.
  • OpenAI API (OpenAI): uma das plataformas mais avançadas para integração de modelos de linguagem natural, como GPT (Generative Pre-trained Transformer), em aplicações. A OpenAI API permite realizar tarefas como geração de texto, tradução, resumo, atendimento automatizado, análise semântica e muito mais. É amplamente utilizada em chatbots, automação de conteúdo, assistentes virtuais e outras soluções baseadas em linguagem.

5 – Chatbots de IA

Os chatbots representam uma das aplicações mais visíveis e interativas da Inteligência Artificial, especialmente na área de Processamento de Linguagem Natural (PLN). Eles são softwares projetados para simular uma conversa humana, seja por texto ou voz. Os avanços recentes, impulsionados pelo Deep Learning, levaram a uma nova geração de chatbots muito mais avançados e sofisticados, entre os quais se destacam:

5.1 – Os principais chatbots da atualidade

  • ChatGPT (OpenAI): sem dúvida, um dos chatbots mais populares e influentes dos últimos tempos. Baseado nos modelos de linguagem GPT (Generative Pre-trained Transformer), é capaz de gerar textos coerentes e relevantes para uma vasta gama de tópicos, responder a perguntas complexas, escrever códigos, criar conteúdo criativo e muito mais. Sua versatilidade o tornou uma ferramenta poderosa para criadores de conteúdo, desenvolvedores e usuários em geral.
  • Google Gemini (Google): o Gemini é um modelo de IA multimodal que compete diretamente com o ChatGPT. Ele é projetado para ser altamente eficaz ao lidar com diferentes tipos de dados, incluindo texto, código, áudio, imagem e vídeo, prometendo uma experiência de conversação e geração de conteúdo ainda mais rica e integrada com o ecossistema Google.
  • Copilot (Microsoft): integrado aos produtos Microsoft (como Bing Chat, Microsoft 365, GitHub), o Copilot atua como um assistente de IA. No Bing Chat, ele potencializa a busca conversacional; no Microsoft 365, ajuda na criação de documentos e apresentações; e no GitHub, auxilia programadores na escrita de código. Sua força está na integração profunda com ferramentas de produtividade.
  • Claude (Anthropic): desenvolvido pela Anthropic, uma empresa focada em IA responsável e ética, o Claude é um modelo de linguagem que busca ser útil, inofensivo e honesto. Ele é conhecido por sua capacidade de lidar com conversas mais longas e por seu foco em segurança e alinhamento, sendo uma alternativa robusta para tarefas que exigem sensibilidade e confiabilidade.

Esses chatbots nos mostram como a IA está transformando a interação humano-máquina, tornando-a mais natural e eficiente. Eles estão redefinindo a forma como buscamos informações, aprendemos e criamos conteúdo.

Conclusão

A Inteligência Artificial é um campo em constante evolução, com o potencial de transformar a maneira como vivemos, trabalhamos e interagimos com o mundo. A Inteligência Artificial já não é mais uma promessa distante: está presente em nossas casas, celulares, carros e até em diagnósticos médicos.

Compreender o funcionamento das IAs é essencial para profissionais e estudantes de tecnologia, bem como para qualquer pessoa que queira entender o futuro que está se desenhando agora e se beneficiar dessa revolução tecnológica.

Espero que este conteúdo seja útil de alguma forma para você. Se gostou do conteúdo, compartilhe com seus amigos e aproveite para conhecer mais sobre TI e desenvolvimento de software.

O que é Java?

Java. Provavelmente, você já ouviu falar desse termo, seja em uma aula da faculdade, durante o desenvolvimento de um software, ou até mesmo no dia a dia, ao se deparar com algum aplicativo ou sistema. Mas o que exatamente é o Java? E por que ele é tão importante no mundo da programação?

Neste artigo, vamos mergulhar no universo Java, desvendando seus conceitos fundamentais, sua história, como dar os primeiros passos na sua instalação e até mesmo desenvolver um pequeno projeto prático. Vamos começar?

1 – O que é Java?

O Java é uma linguagem de programação de alto nível, orientada a objetos, reconhecida pela sua portabilidade e robustez. Desenvolvida pela Sun Microsystems (adquirida pela Oracle em 2010), a linguagem foi lançada em 1995 e rapidamente se tornou uma das mais populares e amplamente utilizadas no mundo.

Sua filosofia principal é “Write Once, Run Anywhere” (WORA), que significa “Escreva uma vez, execute em qualquer lugar”. Isso é possível graças à Máquina Virtual Java (JVM), que interpreta o código Java compilado (bytecode) e o executa em diferentes plataformas, independentemente do sistema operacional subjacente. Isso lhe confere uma portabilidade excepcional, sendo um dos seus principais diferenciais em comparação com outras linguagens disponíveis no mercado.

O Java é a base para uma infinidade de aplicações, como sistemas corporativos robustos, aplicativos móveis (principalmente Android), aplicações web (backends), jogos, Big Data, Internet das Coisas (IoT) e muito mais.

1.1 – Principais características

Até agora, já conseguimos ver que o Java se destaca por diversas características que o tornam uma escolha atraente para diversos projetos de desenvolvimento, desde os mais simples aos mais complexos. Porém, há uma série de outras características que tornam essa linguagem ainda mais poderosa:

  • Orientação a Objetos: tudo em Java é um objeto (com poucas exceções). Isso facilita a modelagem do mundo real em código, promovendo a reutilização, a modularidade e a manutenção do software.
  • Portabilidade: como mencionado, a JVM garante que o código Java possa ser executado em qualquer sistema operacional que possua uma JVM instalada, sem necessidade de recompilação.
  • Segurança: a linguagem foi projetada com a segurança em mente desde o início. A JVM oferece um ambiente seguro para a execução de programas, com recursos como sandboxing e verificação de bytecode.
  • Robustez: juntamente com a segurança, há também um forte tratamento de erros e exceções, o que ajuda a construir aplicações mais confiáveis e menos propensas a falhas.
  • Multithreading: o Java é uma linguagem que suporta multithreading nativamente, permitindo que os programas executem múltiplas tarefas simultaneamente, otimizando o uso dos recursos do processador e melhorando o desempenho das aplicações.
  • Alto Desempenho: embora seja interpretada pela JVM, o JIT (Just-In-Time) compiler otimiza o bytecode em tempo de execução, resultando em um desempenho muito próximo ao de linguagens compiladas.
  • Grandes Bibliotecas e Ecossistema: desenvolvedores Java possuem uma vasta coleção de APIs (Application Programming Interfaces) padrão e um enorme ecossistema de bibliotecas e frameworks de terceiros, o que acelera o desenvolvimento e oferece soluções para praticamente qualquer necessidade.
  • Comunidade Ativa: a comunidade Java é uma das maiores e mais ativas do mundo, oferecendo suporte, recursos, tutoriais e soluções para os mais diversos problemas.

2 – Como surgiu o Java?

A história do Java começa no início da década de 1990, na Sun Microsystems. Originalmente, o projeto, liderado por James Gosling, era conhecido como “Oak” e tinha como objetivo criar uma linguagem para dispositivos embarcados e eletrônicos de consumo. A ideia era ter uma linguagem que fosse independente de plataforma, leve e confiável.

No entanto, com o boom da World Wide Web, a equipe percebeu o potencial da sua criação para o desenvolvimento de aplicações para a internet. Em 1995, a linguagem foi oficialmente lançada com o nome Java, e rapidamente ganhou popularidade devido à sua capacidade de criar applets (pequenos programas executados em navegadores web), revolucionando a forma como o conteúdo interativo era entregue online. Desde então, a linguagem evoluiu e se adaptou, expandindo-se para diversos outros domínios de aplicação.

Em 2010, a Oracle Corporation adquiriu a Sun Microsystems e passou a ser a responsável pelo desenvolvimento e manutenção do Java até os dias atuais.

3 – Como instalar o Java?

Para começar a programar em Java, é necessário instalar o JDK (Java Development Kit), o qual inclui o compilador (chamado javac), ferramentas de desenvolvimento e a JVM (Java Virtual Machine). A seguir, vamos ver como instalar o Java nos principais sistemas operacionais:

3.1 – Instalação no Windows

1 – Acesse o site oficial da Oracle e baixe o instalador compatível com seu sistema (Windows x64 Installer).
2 – Execute o arquivo .exe e siga os passos do assistente de instalação.
3 – Após a instalação, se necessário, adicione o caminho do Java (geralmente C:\Program Files\Java\jdk-xx\bin) à variável de ambiente Path.
4 – Para verificar se está tudo certo, abra o Prompt de Comando e digite:

java -version

3.2 – Instalação no Linux

1 – Atualize os repositórios:

sudo apt update

2 – Instale o JDK:

sudo apt install openjdk-17-jdk

(Esse comando instala a versão 17 do Java. Substitua openjdk-17-jdk pela versão desejada, por exemplo, openjdk-11-jdk para a versão 11).

java -version

Além dos comandos acima, você também pode instalar o Java via pacote .tar.gz, .rpm ou .deb, os quais podem ser encontrados aqui.

3.3 – Instalação no macOS

1 – Baixe o JDK no site da Oracle.
2 – Execute o instalador .dmg.

O JDK será instalado no caminho padrão: /Library/Java/JavaVirtualMachines/.

3 – Para verificar: java -version

Caso prefira, também é possível instalar o Java no macOS utilizando o Homebrew:

brew install openjdk

3.4 – Escolhendo a IDE

Embora seja possível programar em Java com qualquer editor de texto, o uso de uma IDE (Integrated Development Environment) torna o desenvolvimento mais produtivo. Algumas das IDEs mais populares são:

  • IntelliJ IDEA: muito usado por profissionais de programação, oferece recursos avançados de análise de código e integração com frameworks modernos.
  • Eclipse: uma IDE gratuita e altamente extensível, usada amplamente em projetos corporativos.
  • NetBeans: simples e direta, essa IDE é ideal para quem está começando.
  • VS Code: um editor de código leve com suporte a Java via extensões. Ideal para quem prefere um ambiente mais genérico e quando se possui recursos limitados no computador.

4 – Java na prática: calculando variação percentual

Agora que temos o ambiente configurado, vamos colocar a mão na massa com um exemplo prático. Em vez do tradicional “Hello World!”, vamos desenvolver um programa que calcula a variação percentual entre dois números informados pelo usuário via terminal.

A fórmula para calcular a variação percentual é:

Variação percentual = ((Valor Final – Valor Inicial)/Valor Inicial) x 100

Vamos começar criando um arquivo chamado CalculadoraVariacaoPercentual.java. Nosso código para fazer esse cálculo será esse aqui:

import java.util.Scanner; // Importa a classe Scanner para ler a entrada do usuário

public class CalculadoraVariacaoPercentual {

    public static void main(String[] args) {

        // Cria um objeto Scanner para ler a entrada do console
        Scanner scanner = new Scanner(System.in);

        System.out.println("--- Calculadora de Variação Percentual ---");

        // Solicita e lê o valor inicial
        System.out.print("Digite o valor inicial: ");
        double valorInicial = scanner.nextDouble(); // Lê um número decimal (double)

        // Solicita e lê o valor final
        System.out.print("Digite o valor final: ");
        double valorFinal = scanner.nextDouble(); // Lê um número decimal (double)

        // Verifica se o valor inicial é zero para evitar divisão por zero
        if (valorInicial == 0) {
            System.out.println("Erro: O valor inicial não pode ser zero para calcular a variação percentual.");
        } else {
            // Calcula a variação
            double variacao = valorFinal - valorInicial;

            // Calcula a variação percentual
            double variacaoPercentual = (variacao / valorInicial) * 100;

            // Exibe os resultados
            System.out.println("\n--- Resultados ---");
            System.out.println("Valor Inicial: " + String.format("%.2f", valorInicial)); // Formata para 2 casas decimais
            System.out.println("Valor Final: " + String.format("%.2f", valorFinal));   // Formata para 2 casas decimais
            System.out.println("Variação Absoluta: " + String.format("%.2f", variacao)); // Formata para 2 casas decimais
            System.out.println("Variação Percentual: " + String.format("%.2f", variacaoPercentual) + "%"); // Formata e adiciona '%'
        }

        scanner.close(); // Fecha o objeto Scanner para liberar recursos
    }
}

Conclusão

Java é uma das linguagens mais relevantes no mundo da programação. Reconhecido como uma linguagem de programação poderosa e versátil, o Java possui uma história rica e um futuro promissor. Sua portabilidade, robustez, o vasto ecossistema e uma grande comunidade ativa tornam-na em uma excelente escolha para o desenvolvimento de uma ampla gama de aplicações.

Se você está pensando em aprender uma linguagem de programação, Java é, sem dúvida, uma excelente porta de entrada para o mundo do desenvolvimento de software. Com as ferramentas certas e o ambiente de desenvolvimento configurado, você está pronto para explorar todo o potencial dessa poderosa linguagem. Aproveite para criar seus primeiros projetos e junte-se à vibrante comunidade Java!

Espero que este conteúdo seja útil de alguma forma para você. Se gostou do conteúdo, compartilhe com seus amigos e aproveite para conhecer mais sobre programação aqui!

O que é programação estruturada?

No vasto universo do desenvolvimento de software, compreender os diferentes paradigmas de programação é crucial para qualquer profissional da área. Entre eles, a programação estruturada se destaca como um dos pilares que moldaram a forma como construímos sistemas. Mas o que exatamente ela significa e por que é tão relevante até hoje?

Neste texto, vamos entender o que é esse paradigma, como ele surgiu, quais são suas principais características e estruturas, e por que ele ainda é fundamental no aprendizado e, na prática da programação.

1 – O que é programação estruturada?

A programação estruturada é um paradigma de programação que preconiza a criação de programas organizados e de fácil entendimento, utilizando um conjunto limitado de estruturas de controle de fluxo. Ela surgiu como uma resposta aos desafios da programação não estruturada, que resultava em códigos complexos e difíceis de manter, popularmente conhecidos como “código espaguete”.

O objetivo principal da programação estruturada é simplificar o processo de desenvolvimento e depuração, promovendo a clareza e a modularidade do código. Em vez de saltos incondicionais (como o GOTO), ela incentiva o uso de construções bem definidas.

A programação estruturada parte da ideia central de que podemos desenvolver qualquer software, por mais complexo que ele seja, utilizando apenas três estruturas fundamentais de controle de fluxo.

  • Sequência: o sistema executa as instruções em ordem linear, uma após a outra. Essa é a forma mais básica de organizar um código, onde o sistema lê e processa cada comando na sequência em que ele aparece.
  • Seleção (ou Condição): permite que o programa execute diferentes blocos de código com base em uma condição. As estruturas mais comuns são o if/else (se/senão) e o switch/case (escolha/caso). Isso dá ao programa a capacidade de tomar decisões.
  • Iteração (ou Repetição/Loop): permite executar um bloco de código repetidamente enquanto uma condição for verdadeira ou por um número específico de vezes. Exemplos incluem for (para), while (enquanto) e do-while (faça-enquanto). Essas estruturas são essenciais para automatizar tarefas repetitivas.

Linguagens tradicionais como C, Pascal, Fortran, e ALGOL, por exemplo, adotam amplamente o paradigma da programação estruturada. Além delas, atualmente, muitas linguagens modernas como JavaScript, Python, PHP e outras também incorporam os princípios desse paradigma.

Em suma, a programação estruturada defende que a combinação dessas três estruturas básicas é suficiente para construir algoritmos eficientes, claros e fáceis de manter, independentemente da complexidade do problema.

2 – Quando esse paradigma de programação surgiu?

A programação estruturada ganhou força na década de 1960, impulsionada principalmente pelos trabalhos do cientista da computação Edsger W. Dijkstra. Na época, o desenvolvimento de software enfrentava uma crise de produtividade e qualidade. Os programas eram escritos de forma caótica, com muitos saltos GOTO que dificultavam o rastreamento do fluxo de execução e a identificação de erros. Desse modo, a manutenção e a expansão dos sistemas tornava-se um verdadeiro pesadelo.

Dijkstra, em seu famoso artigo “Go To Statement Considered Harmful” (Declaração Go To Considerada Prejudicial) de 1968, criticou severamente o uso indiscriminado do GOTO, argumentando que ele levava a programas “espalhafatosos” e ininteligíveis. Sua proposta era justamente a utilização das três estruturas de controle que mencionamos: sequência, seleção e iteração.

Assim, o surgimento da programação estruturada representou um avanço significativo para a engenharia de software, promovendo a modularidade, legibilidade e manutenibilidade do código. Ao dividir o programa em blocos menores e mais gerenciáveis (como funções e procedimentos), tornou-se mais fácil para os desenvolvedores entenderem, testarem e corrigirem partes específicas do sistema sem afetar o todo.

3 – Exemplo de programação estruturada

Com a finalidade de ilustrar os conceitos da programação estruturada, vamos analisar um exemplo simples de código que verifica se um número é par ou ímpar. Observe que, para fins didáticos, desenvolvemos esse código em três linguagens diferentes: JavaScript, Python e Java.

Ademais, note em cada linguagem utilizada, como a modularização das funções e o uso das estruturas de controle de fluxo acontecem na prática.

JSPythonC++

// Função para verificar se o número é par ou ímpar 
function verificarParOuImpar(numero) {

    // Utiliza uma estrutura condicional (if/else) para determinar a paridade
    if (numero % 2 === 0) {
        return "O número é par.";
    } else {
        return "O número é ímpar.";
    }
}

// Função principal para executar o programa 
function main() {
    var entradaValida = false;

    // Loop de repetição (while) para obter uma entrada numérica válida do usuário
    while (!entradaValida) {
        var numero = prompt("Digite um número inteiro: ");
        // Verifica se o valor inserido é de fato um número
        if (!isNaN(numero)) {
            entradaValida = true;
        } else {
            console.log("Por favor, digite um número válido.");
        }
    }

    // Invoca a função que checa a paridade do número (fluxo sequencial)
    console.log(verificarParOuImpar(numero));
}

// Inicia a execução do programa chamando a função principal (fluxo sequencial)
main();

# Função para verificar se o número é par ou ímpar
def verificar_par_ou_impar(numero):
    
    # Aplica uma condição (if/else) para checar se o número é par
    if numero % 2 == 0:
        return "O número é par."
    else:
        return "O número é ímpar."

# Função principal para executar o programa
def main():
    entrada_valida = False

    # Itera (loop while) até que o usuário forneça um número inteiro válido
    while not entrada_valida:
        numero_str = input("Digite um número inteiro: ")
        # Confere se a entrada fornecida é um número
        if numero_str.isdigit() or (numero_str.startswith('-') and numero_str[1:].isdigit()):
            numero = int(numero_str)
            entrada_valida = True
        else:
            print("Por favor, digite um número válido.")

    # Aciona a função que determina se o número é par ou ímpar (execução sequencial)
    print(verificar_par_ou_impar(numero))

# Garante que a função principal seja chamada ao executar o script
if __name__ == "__main__":
    main()

#include <iostream>
#include <string>  
#include <limits>   

// Função para verificar se o número é par ou ímpar
std::string verificarParOuImpar(int numero) {
    // Implementação de uma estrutura condicional (if/else) para validação
    if (numero % 2 == 0) {
        return "O número é par.";
    } else {
        return "O número é ímpar.";
    }
}

// Função principal para executar o programa
int main() {
    bool entradaValida = false;
    int numero = 0; // Inicializa a variável para ser usada no escopo

    // Estrutura de repetição (while) para garantir uma entrada numérica correta
    while (!entradaValida) {
        std::cout << "Digite um número inteiro: ";
        // Tenta ler um número inteiro
        if (std::cin >> numero) {
            entradaValida = true;
        } else {
            std::cout << "Por favor, digite um número válido." << std::endl;
            // Limpa o estado de erro do cin e descarta o restante da linha de entrada
            std::cin.clear();
            std::cin.ignore(std::numeric_limits::max(), '\n');
        }
    }

    // Chama a função que verifica a paridade do número (fluxo de execução)
    std::cout << verificarParOuImpar(numero) << std::endl;

    return 0; // Indica que o programa terminou com sucesso
}

Nestes exemplos, podemos observar claramente os princípios da Programação Estruturada aplicados na prática:

  • Modularidade: nas três linguagens que utilizamos em nosso exemplo, o código é dividido em duas funções, cada uma delas com sua responsabilidade específica.
    • verificarParOuImpar: função para verificar se o número é par ou ímpar.
    • main: função principal para executar o programa.
  • Estruturas de Controle: utilizamos if/else para tomar decisões (verificar par/ímpar e validar a entrada) e um while para repetir a solicitação de entrada até que um número válido seja fornecido.
  • Sequência: observe em todos os códigos que, tanto a organização das instruções dentro de cada função e as suas respectivas chamadas ocorrem em uma ordem lógica e sequencial.

Apesar de novos paradigmas terem surgido, como a programação orientada a objetos, a programação estruturada continua sendo a base para a escrita de código legível, eficiente e fácil de manter. Portanto, entender seus conceitos é fundamental para qualquer desenvolvedor que busca construir sistemas robustos e de alta qualidade.

Conclusão

A programação estruturada representou um divisor de águas na história do desenvolvimento de software, ao propor uma abordagem mais clara, lógica e modular para a construção de programas.

Mesmo que outros paradigmas tenham surgido, como a programação orientada a objetos e programação funcional, por exemplo, os princípios da programação estruturada continuam sendo amplamente utilizados e valorizados.

Por fim, podemos compreender que dominar a programação estruturada é um passo essencial para qualquer desenvolvedor, pois ela fornece a base para escrever códigos mais organizados, legíveis e fáceis de manter — qualidades indispensáveis na criação de sistemas robustos e duradouros.

Espero que este conteúdo seja útil de alguma forma para você. Se gostou do conteúdo, compartilhe com seus amigos e aproveite para conhecer mais sobre programação aqui!

Como manter a segurança na internet?

Em um mundo cada vez mais conectado, onde a tecnologia permeia cada aspecto de nossas vidas, a segurança na internet se tornou um dos temas mais importantes da atualidade. Nossas informações pessoais, financeiras e profissionais estão constantemente transitando por redes e dispositivos, tornando-nos alvos potenciais para ataques cibernéticos.

Mas o que significa, de fato, “manter a segurança na internet”? Muito mais do que apenas criar senhas complexas, a segurança na internet envolve um conjunto de hábitos, ferramentas e conhecimentos que, juntos, formam uma barreira robusta contra as ameaças digitais.

Neste artigo, vamos explorar os principais pilares da segurança digital e apresentar boas práticas que podem (e devem) ser adotadas por qualquer pessoa — seja você um profissional de TI, estudante da área ou alguém que procura simplesmente navegar com mais tranquilidade.

1. O alicerce da segurança na internet: senhas fortes e únicas

Não há como falar de segurança na internet sem começar pelas senhas. Elas são, literalmente, as chaves que protegem nossas contas e informações de acessos indevidos. Subestimar a importância das senhas é uma das maiores vulnerabilidades que muitos de nós criamos.

Para proteger nossa privacidade na internet, o primeiro passo é criar senhas fortes. Para isso, elas devem atender a alguns requisitos fundamentais:

  • Crie senhas longas: uma senha deve ter, no mínimo, 8 caracteres. Mas o ideal é que ela seja ainda mais longa. Quanto mais caracteres, mais tempo e recursos são necessários para quebrá-la em um ataque de força bruta.
  • Combine números, letras e caracteres especiais: jamais utilize padrões óbvios como “123456” ou “abcdef”. A força de uma senha reside na combinação aleatória de letras maiúsculas e minúsculas, números e caracteres especiais (como !, @, #, $, %, etc.). Pense em frases longas e fáceis de memorizar, mas difíceis de adivinhar.
  • Nada de senhas óbvias: datas de nascimento (a sua ou de pessoas próximas), nomes de parentes, nomes de animais de estimação, nome do time de futebol que você torce. Essas informações e quaisquer outras de cunho pessoal podem ser facilmente encontradas em suas redes sociais e na internet em geral. Assim, esse tipo de senha pode servir como uma porta de entrada para invasores. Seja criativo na hora de criar suas senhas e evite dados que possam ser facilmente associados a você.

2. Comportamentos que fortalecem sua segurança na internet

Criar senhas fortes é o primeiro passo, mas a segurança na internet vai além disso e exige a adoção de vários comportamentos conscientes. Ignorar esses comportamentos e não os adotar em seu dia a dia pode anular todo o seu esforço inicial de criar senhas fortes.

  • A regra de ouro: senhas únicas para cada serviço: reutilizar a mesma senha em diversas plataformas é um erro grave. Você já parou para pensar que, ao repetir sempre a mesma senha em todos os lugares, basta que apenas uma de suas contas seja comprometida e o invasor terá acesso a todas as outras onde você usa a mesma credencial? Invista na criação de senhas diferentes para cada serviço que você usa.
  • Não anote suas senhas: anotar suas senhas em papéis, blocos de anotações ou arquivos de texto não protegidos é extremamente perigoso. Se essas anotações, físicas ou virtuais, caírem em mãos erradas, sua privacidade estará comprometida. Procure utilizar mecanismos confiáveis de gerenciamento de senhas para não precisar recorrer às anotações.
  • Atualize suas senhas periodicamente: vazamentos de dados são uma realidade e podem acontecer a qualquer momento, para qualquer empresa. Mesmo que as empresas que armazenam nossos dados tomem as melhores medidas e usem os melhores recursos e ferramentas de segurança digital, ainda assim suas informações podem ser expostas. Por isso, crie o hábito de atualizar suas senhas regularmente, pelo menos uma vez ao ano para serviços comuns e com mais frequência para serviços críticos como seu e-mail principal e suas contas bancárias.

3. Camadas extras de proteção: medidas adicionais de segurança

A sofisticação dos ataques cibernéticos é cada vez maior e para nos proteger precisamos ir além do básico. Integrar medidas adicionais de segurança ao seu dia a dia é crucial para impedir a ação de criminosos digitais:

  • Utilize gerenciadores de senhas: com a quantidade de serviços digitais que utilizamos hoje em dia, memorizar senhas únicas para cada um é praticamente impossível. Nesse contexto, os gerenciadores de senhas são importantes ferramentas que armazenam suas credenciais de forma criptografada e segura. Isso lhe permite criar senhas complexas e únicas para cada serviço sem a necessidade de memorizá-las. Muitos desses serviços oferecem versões gratuitas e são compatíveis com diversos dispositivos.
  • Configure a autenticação multifator (MFA): a autenticação multifator (MFA) adiciona uma poderosa camada extra de proteção aos seus serviços digitais. Mesmo que sua senha seja descoberta por um invasor, ele ainda precisará superar um segundo fator de autenticação para acessar sua conta. Isso pode ser um código enviado por SMS, e-mail, aplicativo autenticador (como Google Authenticator ou Microsoft Authenticator) ou até mesmo sua impressão digital. Ative a MFA sempre que disponível, pois esta é uma das medidas mais eficazes para prevenir acessos indevidos.
  • Mantenha seus softwares atualizados: as atualizações de software, seja do seu sistema operacional (Windows, macOS, Android, iOS) ou de seus aplicativos, não trazem apenas novas funcionalidades. Elas corrigem vulnerabilidades de segurança que poderiam ser exploradas por invasores. Por isso, mantenha seus dispositivos e softwares sempre atualizados.

4 – Comportamentos extras para aumentar a segurança na internet

Além das medidas adicionais de segurança que podemos adotar em nossos dispositivos e sistemas, há também alguns comportamentos simples que podemos adotar para aumentar nossa segurança na internet:

  • Desconfie sempre: essa é uma regra fundamental. Jamais forneça suas senhas ou códigos de autenticação a terceiros, independentemente da justificativa ou do meio de comunicação utilizado (telefone, e-mail, WhatsApp, redes sociais). Empresas e instituições legítimas nunca solicitarão suas credenciais de acesso dessa forma. Desconfie de mensagens ou ligações suspeitas e, se necessário, procure as autoridades competentes.
  • Evite usar redes Wi-fi públicas: redes públicas, como as oferecidas em shoppings, cafés e aeroportos, são muito práticas, mas também muito perigosas. Geralmente, essas redes não possuem uma boa proteção e podem ser um alvo fácil para criminosos que tentam interceptar seus dados. Não as utilize para acessar informações sensíveis, como dados bancários ou e-mails importantes. Prefira utilizar sua conexão 4G/5G. Porém, se precisar utilizá-las, opte por uma VPN (Rede Privada Virtual), que cria uma conexão criptografada e segura, dificultando a interceptação das suas informações.
  • Não clique em links e anexos suspeitos: sempre desconfie de links ou anexos recebidos por e-mail, SMS ou aplicativos de mensagens, especialmente se a mensagem for alarmista ou pedir para você tomar uma atitude urgente. Clicar em links maliciosos ou baixar anexos infectados pode instalar programas espiões no seu dispositivo ou direcioná-lo para páginas falsas que roubam suas informações de login. Verifique sempre o remetente e o conteúdo antes de clicar e, em caso de dúvida, entre em contato, por meio de um canal oficial, diretamente com a empresa ou pessoa que supostamente lhe enviou a mensagem.

Conclusão

Manter a segurança na internet é um processo contínuo que envolve a criação de senhas fortes, a adoção de comportamentos seguros e o uso dos recursos tecnológicos de segurança disponíveis. É dessa forma que você deixa de ser uma presa fácil para invasores e constrói uma verdadeira muralha contra ameaças cibernéticas, podendo usufruir dos benefícios da internet de forma segura e tranquila.

Lembre-se: suas informações pessoais são valiosas e proteger seus dados é proteger a si mesmo. Por isso, invista na sua segurança digital e proteja sua privacidade em um mundo cada vez mais conectado.

Espero que este conteúdo seja útil de alguma forma para você. Gostou do post? Compartilhe com seus amigos e aproveite para conhecer mais sobre segurança da informação clicando aqui!

O que é Python?

Considerada uma das linguagens mais populares e poderosas da atualidade, o Python vem conquistando tanto iniciantes quanto profissionais experientes por sua simplicidade, versatilidade e ampla gama de aplicações.

Mas o que exatamente torna o Python tão especial? Por que ele é recomendado como primeira linguagem para quem está começando, e ao mesmo tempo é utilizado em grandes projetos de empresas como Google, Netflix e NASA?

Neste artigo, vamos explorar o que é Python, suas principais características, onde e como surgiu, como instalá-lo no seu computador e, por fim, veremos um exemplo prático que demonstra como a linguagem funciona.

Se você está dando os primeiros passos no mundo da programação ou simplesmente quer entender por que o essa lingaugem é tão popular, este guia é para você. Vamos começar?

1- O que é Python?

Python é uma linguagem de programação de alto nível, interpretada, de propósito geral e multiparadigma. Mas o que isso significa na prática?

  • Alto Nível: isso quer dizer que Python se aproxima mais da linguagem humana do que da máquina, tornando-o mais fácil de ler e escrever.
  • Interpretada: ao contrário de linguagens compiladas (como C++ ou Java), o código Python é executado linha por linha por um interpretador, sem a necessidade de um processo de compilação prévia. Isso agiliza o desenvolvimento e a depuração.
  • Propósito Geral: Python não é uma linguagem restrita a uma área específica. Ela pode ser utilizada no desenvolvimento web, inteligência artificial, ciência de dados, automação, jogos, finanças e muito mais.
  • Multiparadigma: Suporta diferentes estilos de programação, incluindo programação orientada a objetos (POO), programação funcional e programação imperativa.

Python é uma linguagem que possui sintaxe simples e intuitiva, projetada para ser fácil de ler e escrever. São essas características que a tornam ideal tanto para iniciantes quanto para desenvolvedores experientes.

Além disso, sua vasta quantidade de bibliotecas disponíveis fazem dela uma escolha sólida para uma ampla gama de aplicações, desde simples scripts de análises de dados até sistemas complexos de automação de tarefas.

1.1 – Principais características do Python

Além das caracterísitcas apresentadas acima, o Python possui outras que ajudaram a linguagem a se popularizar na comunidade de desenvolvimento:

  • Tipagem dinâmica: não é necessário declarar o tipo das variáveis. A definição dos tipos ocorre em tempo de execução do código.
  • Portabilidade: códigos Python podem ser executados em diferentes sistemas operacionais (Windows, Linux, macOS), exigindo pouca ou nenhuma modificação. Escreva uma vez, execute em qualquer lugar.
  • Sintaxe simples e legível: a sintaxe de Python é extermamente limpa e intuitiva, assemelhando-se ao inglês. Isso facilita a criação, o entendimento e a manutenção do código no longo prazo.
  • Grande Biblioteca Padrão e Ecossistema Rico: o Python fornece uma vasta coleção de módulos e pacotes pré-construídos que permitem realizar uma infinidade de tarefas sem “reinventar a roda”. Além disso, o ecossistema é complementado por milhares de bibliotecas de terceiros (como pandas para análise de dados, requests para requisições HTTP, Django e Flask para desenvolvimento web, e TensorFlow para aprendizado de máquina).
  • Comunidade Ativa e Abrangente: Há uma comunidade global massiva de desenvolvedores Python. Isso significa que você sempre encontrará suporte, documentação detalhada, tutoriais e uma infinidade de recursos para ajudar no seu aprendizado e na solução de problemas.

2 – Onde e como o Python surgiu?

Python foi criado, no final dos anos 1908, por Guido van Rossum, um programador holandês. Sua primeira versão oficial (0.9.0) foi lançada em 1991. A ideia de Guido era desenvolver uma linguagem que fosse tão poderosa quanto o C, mas que possuísse uma sintaxe mais simples e encorajasse a adoção de boas práticas de programação.

O nome Python não veio do animal, mas sim do grupo britânico de comédia Monty Python’s Flying Circus, do qual Guido era fã.Ele resolveu homenagear o grupo nomeando sua linguagem dessa forma.

Desde seu lançamento, o Python evoluiu muito e se tornou uma das linguagens mais dominantes no cenário tecnológico global.

3 – Como instalar o Python

Instalar o Python é um processo relativamente simples, mas varia um pouco dependendo do seu sistema operacional. Abaixo veremos os passos básicos para os principais sistemas operacionais:

3.1 – Windows

No Windows você pode utilizar um executável para instalar o Python na sua máquina:

  1. Acesse a página oficial de downloads aqui.
  2. Selecione a versão recomendada para seu Windows e faça seu download.
  3. Execute o instalador e não esqueça de marcar a opção “Add Python to PATH” antes de continuar. Essa etapa é muito importante, pois, criará de forma automática uma variável de ambiente para a linguagem.
  4. Clique em Install Now e aguarde a conclusão.
  5. Verificação: Abra o Prompt de Comando do Windows. Para isso pressione Win + R, ou abra o menu iniciar, digite cmd e pressione Enter. No cmd digite python --version ou py --version. Com isso, você visualizará a versão do Python instalada em seu computador.

3.2 – Linux (Debian/Ubuntu)

A maioria das distribuições Linux já vem com o Python instalado por padrão, não havendo necessidade executar os passos a seguir. Porém, se a sua distribuição Linux não vier com a linguagem instalada por padrão, basta executar os comandos abaixo no seu terminal:

sudo apt update
sudo apt install python3

Para verificar a versão do Python instalada no seu Linux, abra o Terminal e digite python3 --version.

3.3 – macOS

No macOs a forma mais prática de instalar o Python é através do gerenciador de pacotes Homebrew. Se você não o tem, instale-o com:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Após instalar o Homebrew, instale Python com o seguinte comando:

brew install python

Para verificar a versão instalada, abra o Terminal e digite python3 --version.

3.4 – Escolhendo uma IDE

Seja qual for seu sistema operacional, assim que concluída a instalação do Python, você precisará de uma IDE para escrever seus códigos de forma eficiente. Eu particularmente, já trabalhei e gosto de duas IDEs para Python: o Visual Studio Code e o PyCharm. Fica a seu critério escolher uma dessas duas IDEs ou outra que seja do seu gosto para começar a codar.

4 – Usando o Python na prática

Depois de instalar o Python, chegou a hora de escrevermos nosso primeiro código. Vamos criar um pequeno script que solicita o nome do usuário e calcula a sua idade com base no ano de nascimento informada:

nome = input("Digite seu nome: ")
ano_nascimento = int(input("Digite seu ano de nascimento: "))
ano_atual = 2025

idade = ano_atual - ano_nascimento

print(f"Olá, {nome}! Pelos meus cálculos, agora em {ano_atual}, você tem {idade} anos.")

Esse pequeno script já introduz conceitos importantes da linguagem, como:

  • Leitura de entrada com input()
  • Conversão de tipos (int)
  • Operações matemáticas
  • Uso de variáveis e interpolação de strings com f-strings

Salve esse arquivo com um nome como calcula_idade.py. Independente do nome que você escolher, o importante é que o arquivo possua a extensão.py. Agora, no seu terminal, acesse o diretório onde salvou o arquivo e execute-o com o comando:

python calcula_idade.py

O script irá solicitar seu nome e ano de nascimento e lhe dará um retorno semelhante a esse aqui:

Conclusão

O Python é uma linguagem acessível, poderosa e extremamente versátil. Sua sintaxe clara facilita o aprendizado e permite que o programador foque mais na lógica do problema e menos nos detalhes técnicos da linguagem. Por isso, essa linguagem tem sido a porta de entrada de muitos estudantes no mundo da programação e também uma ferramenta indispensável para profissionais experientes de diversas áreas.

Ao longo deste artigo, conhecemos o que é Python, suas principais características, onde surgiu, como instalar no seu computador e vimos um pequeno exemplo de uso. Agora, o próximo passo é com você: explore, experimente e continue aprendendo. O Python tem um ecossistema riquíssimo e uma comunidade ativa que com certeza te ajudará a evoluir rapidamente.

Espero que este conteúdo seja útil de alguma forma para você. Se gostou do conteúdo, compartilhe com seus amigos e aproveite para conhecer mais sobre programação aqui! — tem muito mais esperando por você!

O que é Docker?

Com a crescente demanda por soluções ágeis, escaláveis e portáteis no desenvolvimento de software, o Docker tem se destacado como uma poderosa ferramenta que revolucionou a maneira como aplicações são construídas, distribuídas e executadas.

Baseado na ideia de automatizar a implantação de aplicações por meio de contêineres, o Docker tem ganhado popularidade e notoriedade na comunidade de desenvolvimento devido a sua versatilidade, agilidade e eficiência.

Mas afinal, o que é Docker, para que ele serve e como funciona na prática? Neste artigo, você encontrará a resposta para cada uma dessas perguntas. Vamos começar?

1 – O que é Docker e para que serve?

O Docker é uma plataforma de código aberto que permite automatizar o empacotamento, a distribuição e a execução de aplicações em containers. Um container é uma unidade leve, portátil e autossuficiente que contém tudo o que uma aplicação precisa para funcionar: código, bibliotecas, dependências, variáveis de ambiente e arquivos de configuração.

Diferente das tradicionais máquinas virtuais, que emulam sistemas operacionais inteiros, os containers compartilham o núcleo (kernel) do sistema operacional do host, sendo muito mais leves e rápidos.

O Docker permite criar ambientes isolados que garantem que uma aplicação funcione da mesma forma em qualquer lugar — seja em um ambiente de desenvolvimento, em servidores de teste ou em ambientes de produção.

Em suma, o Docker serve para:

  • Facilitar a criação de ambientes consistentes para desenvolvimento, testes e produção;
  • Simplificar o processo de distribuição e implantação de software;
  • Isolar aplicações e serviços;
  • Aumentar a escalabilidade e a portabilidade dos sistemas.

1.1 – Principais características do Docker

As principais características dessa ferramenta incluem:

  • Portabilidade: um container pode ser executado em qualquer lugar que tenha o Docker instalado (Windows, Linux, macOS, servidores em nuvem, etc.).
  • Leveza: os containers utilizam menos recursos que máquinas virtuais, pois compartilham o mesmo kernel do sistema operacional.
  • Isolamento: cada container roda de forma isolada, evitando conflitos entre aplicações e versões de bibliotecas.
  • Rapidez na inicialização: containers iniciam quase instantaneamente.
  • Reprodutibilidade: através dos arquivos Dockerfile, é possível versionar e reproduzir exatamente o mesmo ambiente em diferentes máquinas.
  • Escalabilidade: a integração com ferramentas como Kubernetes, o que agiliza e facilita a escalabilidade de aplicações em ambientes distribuídos.

2 – Como surgiu o Docker?

A ideia de isolamento de processos e contêineres não é nova, existindo conceitos similares há décadas, desde os antigos sistemas Unix (como LXC). No entanto, o Docker popularizou e simplificou significativamente o uso de contêineres, tornando-os acessíveis a um público muito mais amplo.

No ano de 2010, o Docker nasceu, originalmente, para uso interno da empresa de plataforma como serviço (PaaS) DotCloud (que posteriormente mudou seu nome para Docker Inc.), fundada por Solomon Hykes na França.

Foi em março de 2013 que o Docker foi lançado ao público como um projeto de código aberto. Sua facilidade de uso, a vasta comunidade que se formou ao redor e a solução eficaz para os desafios de implantação rapidamente impulsionaram sua adoção em todo o mundo.

A visão por trás do Docker era fornecer uma maneira padronizada e portátil de empacotar e executar aplicações, independentemente da infraestrutura subjacente. Essa abordagem resolveu muitos dos problemas enfrentados por desenvolvedores e equipes de operações, como inconsistências de ambiente, dificuldades de implantação e lentidão no ciclo de desenvolvimento.

3 – Como instalar o Docker?

A instalação do Docker varia conforme o sistema operacional. Abaixo, vamos ver os passos básicos de instalação para os principais sistemas:

3.1 – Windows e macOS

  1. Acesse o site oficial clicando aqui.
  2. Baixe a versão Docker Desktop para o seu sistema.
  3. Siga as etapas do assistente de instalação.
  4. Após instalado, abra o Docker Desktop e aguarde a inicialização do serviço.

3.2 Linux (exemplo para sistemas Ubuntu):

No terminal do Linux, execute os seguintes comandos.

sudo apt update
sudo apt install docker.io -y
sudo systemctl enable docker
sudo systemctl start docker

Com os passos acima, você conseguirá instalar o Docker de forma rápida e fácil em sistemas operacionais Linux. Mas, caso seja necessário, na página oficial do Docker, neste link aqui, você encontra tutoriais mais detalhados, inclusive para outras distribuições Linux além do Ubuntu.

4 – Utilizando o Docker na prática

Para melhorar seu entendimento de Docker vamos elaborar um exemplo simples e prático que lhe ajudará a compreender o funcionamento da ferramenta. Para começar, vamos verificar a versão instalada em seu sistema, executando o comando abaixo no terminal:

docker --version

Esse comando irá retornar a versão instalada em seu sistema, confirmando que as etapas executadas no item anterior foram bem sucedidas.

Agora vamos executar um servidor web (por exemplo, Nginx), com o seguinte comando:

docker run -d -p 8080:80 nginx

Acesse http://localhost:8080 e você verá a página padrão do Nginx rodando em um container.

4.1 – Criando uma aplicação Node.js

Para este exemplo vamos criar uma simples aplicação em Node.js que apresentará uma simples mensagem na tela do usuário. A estrutura do nosso projeto será a seguinte::

meu-app-node/
├── app.js
├── package.json
└── Dockerfile

Vamos criar o arquivo app.js:

const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
  res.send('Olá, esta é uma aplicação Node.js rodando em um container Docker!');
});

app.listen(port, () => {
  console.log(`Servidor rodando em http://localhost:${port}`);
});

O próximo arquivo que criaremos é o package.json:

{
  "name": "meu-app-node",
  "version": "1.0.0",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  },
  "dependencies": {
    "express": "^4.18.2"
  }
}

Por fim, vamos criar nosso Dockerfile:

# Usa uma imagem oficial do Node.js
FROM node:18

# Cria diretório da aplicação
WORKDIR /app

# Copia arquivos para o container
COPY package*.json ./
RUN npm install

COPY . .

# Expõe a porta 3000
EXPOSE 3000

# Comando para iniciar a aplicação
CMD ["npm", "start"]

4.2 – Executando o container

No seu terminal, navegue até a pasta onde estão os arquivos do seu projeto Node.js e execute o seguinte comando para construir a imagem Docker:

docker build -t meu-app-node .

Agora, vamos executar o container:

docker run -d -p 3000:3000 meu-app-node

Abra seu navegador web e acesse http://localhost:3000

Ao acessar esse endereço você visualizará essa mensagem na tela: “Olá, esta é uma aplicação Node.js rodando em um container Docker!”

Veja como é simples executar uma aplicação Node.js a partir de um container Docker. E o mais interessante de tudo, é que podemos usufruir dos recursos oferecidos pelo Docker para praticamente qualquer linguagem ou tipo de aplicação, mostrando a versatilidade dessa ferramenta e o grande número de possibilidades que temos com ela.

Conclusão

O Docker é uma ferramenta poderosa que transformou o modo como desenvolvedores e equipes de operações criam, testam e implantam aplicações. Com ele, é possível garantir ambientes consistentes, escaláveis e eficientes, otimizando processos de desenvolvimento e entrega contínua.

Se você ainda não experimentou, vale a pena começar — o Docker pode ser um divisor de águas no seu fluxo de trabalho, aumentando a sua produtividade e a qualidade de suas entregas.

Espero que este conteúdo seja útil de alguma forma para você. Se gostou do conteúdo, compartilhe com seus amigos e aproveite para acessar os outros artigos deste site — tem muito mais esperando por você!

O que é um paradigma de programação?

Os paradigmas de programação representam diferentes estilos ou abordagens para escrever e organizar código. Cada paradigma define um modelo conceitual que influencia diretamente como problemas são analisados, como soluções são projetadas e como o software é implementado e mantido. Compreender esses paradigmas é essencial para todo desenvolvedor que deseja escrever código mais eficiente, legível e sustentável.

Neste artigo, vamos explorar os principais paradigmas de programação, suas características, exemplos e quando aplicá-los. Começamos com uma base conceitual.

1 – O que é um paradigma de programação?

Para entendermos o conceito de paradigma de programação, devemos primeiramente compreender o significado da palavra paradigma.  O termo “paradigma” vem do grego paradeigma, que significa modelo ou exemplo. De acordo com o dicionário Priberam, a palavra paradigma pode ser definida como: “Algo que serve de exemplo geral ou de modelo.” 

No contexto da computação, um paradigma de programação é um modelo conceitual que determina a forma de escrever códigos. Eles fornecem diretrizes sobre como estruturar algoritmos, organizar dados e controlar o fluxo de execução.

Linguagens de programação podem seguir um único paradigma (como Haskell, voltada exclusivamente ao paradigma funcional) ou ser multiparadigma, combinando diferentes abordagens (como Python e JavaScript, que suportam paradigmas imperativo, orientado a objetos e funcional).

2. Principais Paradigmas de Programação

Ao longo da evolução da computação, diversos paradigmas foram desenvolvidos para atender a diferentes demandas e contextos. A seguir, vamos conhecer os principais:

2.1 Programação imperativa

A programação imperativa é uma das formas mais tradicionais de programar. Nesse paradigma, o código é escrito como uma sequência de instruções que alteram o estado do sistema. É como dar ordens ao computador: determinando passo a passo, quais comandos ele deve executar e em qual ordem.

Características:

  • Foco em como resolver o problema.
  • Uso explícito de variáveis, laços e estruturas de controle.
  • Controle detalhado do fluxo de execução.

Exemplos de linguagens: C, C++, Java, Python, JavaScript, PHP.

2.2 Programação declarativa

A programação declarativa é conhecida como o oposto da imperativa. Nesse paradigma, o foco recai sobre o que deve ser feito, e não em como deve ser feito. Assim, o programador descreve ao computador a sequência lógica a executar e o resultado que se espera alcançar, sem determinar o fluxo de controle. O sistema se encarrega de executar as ações necessárias para alcançar esse resultado.

Portanto, na programação declarativa, as instruções possuem uma abordagem mais generalista e não detalham exatamente cada etapa da execução.

Características:

  • Abstrai o controle do fluxo de execução.
  • Minimiza efeitos colaterais.
  • Ideal para tarefas onde regras e resultados são mais importantes que o processo.

Exemplos: SQL, HTML, CSS, XML, Prolog.

2.3 Programação estruturada

Derivada do paradigma imperativo, a programação estruturada introduz boas práticas como a divisão do código em blocos lógicos (modularização do software) e está fundamentada no uso de estruturas básicas de controle de fluxo: sequências, decisões e repetições.

Na programação estruturada, entende-se que para resolver um problema de forma eficiente, ele deve ser quebrado em partes menores (subprogramas ou módulos). Cada uma dessas partes será responsável por resolver uma determinada fração do problema maior. Esse é o conceito de modularização de software, onde todo programa é composto por um conjunto de programas menores interconectados, chamados de módulos ou subprogramas. 

Os softwares construídos com esse paradigma usam as seguintes estruturas de controle de fluxo: 

Sequências: as instruções são escritas na sequência em que serão executadas.  

Decisões/condições: blocos de código são executados somente quando determinadas condições são cumpridas. Usa-se estruturas como IF – ELSE e SWITCH – CASE. 

Repetições: blocos de código são executados várias vezes até que uma condição seja cumprida. Usa-se estruturas como FOR, WHILE e Recursividade. 

Características:

  • Redução de código espaguete.
  • Organização por funções e blocos.
  • Uso de estruturas como if/else, switch, for, while.

Exemplos: C, C++, C#, Java, Python, PHP.

2.4 Programação procedural

Também derivada do paradigma imperativo, a programação procedural agrupa as instruções em procedimentos (também chamados de funções, métodos ou sub-rotinas). Cada procedimento realiza uma tarefa específica, promovendo modularização e reutilização de código. Esses procedimentos devem ser acionados sequencialmente, durante a execução do software.

Características:

  • Organização baseada em chamadas de funções.
  • Separação de responsabilidades.
  • Facilidade de manutenção e testes.

Exemplos: C, C++, PHP, Python, Go.

2.5 Programação orientada a objetos (POO)

A programação orientada a objetos também deriva da programação imperativa. É o paradigma mais difundido e usado na atualidade. A POO modela o software com base em objetos do mundo real. A ideia central é replicar o mundo real através de códigos que usam classes e objetos para representar tudo aquilo que existe. 

As classes são os modelos que representam coisas reais. Já os objetos são instâncias dessas classes, que encapsulam dados (atributos) e comportamentos (métodos). Esse paradigma favorece a reutilização, escalabilidade e organização do código.

Características:

  • Encapsulamento, herança, polimorfismo e abstração.
  • Interação entre objetos para compor o comportamento do sistema.
  • Facilita a modelagem de domínios complexos.

Exemplos: Java, C++, C#, Python, Ruby, PHP.

2.6 Programação funcional

Baseada em conceitos matemáticos, a programação funcional trata funções como cidadãos de primeira classe. Ela evita estados mutáveis e prioriza funções puras — que sempre produzem o mesmo resultado para os mesmos argumentos.

Características:

  • Imutabilidade e ausência de efeitos colaterais.
  • Uso intensivo de funções e composição.
  • Paradigma adequado para concorrência e paralelismo.

Exemplos: Haskell, Elixir, Scala, JavaScript (parcialmente), Kotlin (parcialmente).

2.7 Programação lógica

A programação lógica também deriva da programação declarativa. Ela está baseada no uso de regras e lógica formal para resolução de problemas. O programador declara fatos e regras, e o motor de inferência da linguagem deduz as conclusões.

Características:

  • Usa lógica de predicados para inferir respostas.
  • Muito usada em inteligência artificial e sistemas especialistas.

Exemplo: Prolog.

2.8 Programação reativa

Também derivada da programação declarativa, a programação reativa possui foco na construção de sistemas orientados a eventos e fluxo de dados assíncronos. É ideal para aplicações que exigem respostas imediatas a mudanças de estado, como interfaces gráficas e aplicações em tempo real.

Características:

  • Fluxos de dados e propagação de mudanças.
  • Combina bem com programação funcional e orientada a eventos.

Exemplos: RxJS, Reactor (Java), Angular (RxJS), Kotlin Flow.

3. Qual o melhor paradigma de programação?

Depois de ler este artigo, talvez você esteja se perguntando qual o melhor paradigma de programação? E a resposta é: depende. Nenhum paradigma é universalmente melhor, tudo depende do contexto. A escolha do paradigma ideal inclui fatores como:

  • A natureza do problema.
  • Requisitos de desempenho e manutenção.
  • Equipe envolvida e conhecimento técnico.
  • Linguagens e tecnologias adotadas pela organização.

Na prática, muitos projetos adotam uma abordagem híbrida, usando múltiplos paradigmas conforme a necessidade. É comum, por exemplo, combinar POO com técnicas funcionais em linguagens modernas como Python, Kotlin ou JavaScript.

Portanto, cabe aos profissionais de desenvolvimento entender os conceitos básicos de cada paradigma e usá-los de acordo com as suas necessidades.

Conclusão

Conhecer os paradigmas de programação é essencial para desenvolver software de maneira mais eficaz. Eles moldam a maneira como pensamos e resolvemos problemas computacionais.

Ao dominar diferentes paradigmas, o desenvolvedor ganha flexibilidade, capacidade analítica e autonomia para escolher a melhor abordagem para cada desafio. Lembre-se: aprender novos paradigmas amplia sua visão como desenvolvedor e contribui para um código mais limpo, sustentável e adaptável.

Espero que este conteúdo seja útil de alguma forma para você. Se gostou do conteúdo, compartilhe com seus amigos e aproveite para conhecer mais sobre programação aqui!

O que é Node.js?

Com o crescimento constante do desenvolvimento web e a necessidade de aplicações cada vez mais rápidas e escaláveis, surgiram diversas soluções para otimizar o back-end das aplicações. E uma das tecnologias que mais se destacou nesse cenário é o Node.js.

Este ambiente de execução JavaScript permite que desenvolvedores utilizem uma linguagem bastante popular no front-end também no lado do servidor, tornando o desenvolvimento full-stack mais acessível e eficiente.

Neste texto, exploraremos o que é o Node.js, suas principais características, sua origem, como instalá-lo e um exemplo prático para demonstrar seu funcionamento. Vamos lá?

1 – O que é Node.js?

Node.js é um ambiente de execução JavaScript, de código aberto, multiplataforma e do tipo server-side (que é executado do lado do servidor). Ele permite rodar códigos JavaScript fora do navegador web, permitindo usar essa linguagem na criação de diversos tipos de aplicações que vão além de páginas web.

O Node.js é construído sobre o motor JavaScript do Google Chrome, conhecido como “motor V8”, responsável por interpretar código JS de forma extremamente rápida. Na prática, o Node.js pega o motor JavaScript do Google Chrome e o “empacota” para que ele possa ser usado para executar código JS em qualquer lugar, não apenas no seu browser.

Assim, é possível utilizar o Node.js para desenvolver aplicações escaláveis e de alto desempenho, como APIs, servidores web, automações e até mesmo aplicações desktop com frameworks como o Electron.

Diferente de muitas outras linguagens server-side, o Node.js é orientado a eventos e utiliza um modelo assíncrono baseado em callbacks e promises. Isso torna-o muito eficiente para aplicações que exigem alta escalabilidade e I/O intensivo.

1.1 – Principais características

Baseado no Motor V8: como mencionado anteriormente, o coração do Node.js é o motor V8, conhecido por sua alta performance e velocidade na execução de código JavaScript. Isso o torna uma ferramenta altamente eficiente para o desenvolvimento de aplicações web.

Arquitetura Orientada a Eventos e Não Bloqueante (I/O Não Bloqueante): essa é uma das características mais marcantes e poderosas do Node.js. Em vez de esperar que uma operação demorada (como ler um arquivo ou acessar um banco de dados) termine antes de continuar o processamento, o Node.js utiliza um sistema de “funções de callbacks”. Esse sistema de callback permite que o servidor continue processando outras requisições enquanto espera o término de requisições anteriores, tornando-o altamente escalável e capaz de lidar com muitas conexões simultâneas.

Single-Threaded (com Event Loop): apesar de ser single-threaded (usar apenas uma linha de execução principal), o Node.js consegue lidar com concorrência de forma eficiente graças ao seu “event loop”. Esse loop fica constantemente verificando se alguma operação não bloqueante terminou e, em caso afirmativo, executa o callback associado.

Grande Ecossistema de Pacotes (npm): o Node.js possui o gerenciador de pacotes npm (Node Package Manager), o maior ecossistema de bibliotecas e ferramentas de código aberto do mundo. Com o npm, você pode facilmente encontrar e instalar pacotes para praticamente qualquer necessidade, desde frameworks web até utilitários para manipulação de arquivos. Isso acelera muito o desenvolvimento.

JavaScript em Todos os Lugares: uma das grandes vantagens do Node.js é a possibilidade de usar a mesma linguagem (JavaScript) tanto no front-end (navegador) quanto no back-end (servidor). Isso facilita o desenvolvimento full-stack, melhora a comunicação entre as equipes e permite o reaproveitamento de código.

Escalabilidade: devido à sua arquitetura não bloqueante, o Node.js é altamente escalável e adequado para aplicações que precisam lidar com múltiplas conexões simultâneas e alto tráfego.

2 – Como surgiu o Node.js?

A história do Node.js começa com Ryan Dahl, um engenheiro de software que trabalhava no desenvolvimento do Google Chrome. Ele estava frustrado com as limitações dos servidores web tradicionais, especialmente em relação ao gerenciamento de conexões simultâneas.

Dahl percebeu que os servidores web da época (como o Apache) eram ineficientes em operações de I/O, como leitura de arquivos ou acesso ao banco de dados. Em 2009, durante a JSConf EU, ele apresentou o Node.js como uma alternativa. A ideia principal era usar o motor V8 do Chrome, reconhecido por sua alta velocidade e eficiência, para construir um ambiente de execução JavaScript eficiente para o lado do servidor, adotando um modelo assíncrono e baseado em eventos, que traz mais leveza e performance às aplicações.

Alguns dos fatores que contribuíram para o surgimento e sucesso desta ferramenta foram:

  • A popularidade crescente do JavaScript: na época, o JavaScript já era a linguagem dominante no front-end, e a possibilidade de usá-la no back-end abriu novas possibilidades para os desenvolvedores.
  • A necessidade de aplicações web mais escaláveis e em tempo real: aplicações como chats, jogos online e dashboards em tempo real precisavam de tecnologias que pudessem lidar com muitas conexões simultâneas de forma eficiente. O modelo não bloqueante do Node.js se encaixou perfeitamente nessa necessidade.
  • A insatisfação com os modelos de programação tradicionais: muitos desenvolvedores achavam os modelos de programação baseados em threads (comuns em outras linguagens de servidor) complexos e propensos a problemas de concorrência. O modelo orientado a eventos do Node.js ofereceu uma alternativa mais simples e intuitiva.

Desde sua criação, o Node.js cresceu exponencialmente e se tornou uma das tecnologias mais populares e utilizadas no desenvolvimento web. Ele é utilizado para construir desde APIs e microsserviços até aplicações web completas e ferramentas de linha de comando.

3 – Como instalar o Node.js

Instalar o Node.js é um processo simples e fácil. Veja abaixo um passo a passo de como instalá-lo:

3.1 – Acesse o site oficial

  • Vá para: https://nodejs.org
  • Baixe a versão LTS (Long Term Support), compatível com o seu sistema operacional.

3.2 – Instalação do Node.js

  • No Windows, execute o instalador e siga os passos padrão (próximo, próximo… concluir).
  • No Linux, execute os comandos via terminal para instalar os recursos.
  • Observação: durante a instalação, o gerenciador de pacotes Node Package Manager (npm) também será instalado automaticamente.

3.3 – Verifique a instalação

Abra o terminal ou prompt de comando e digite:

node -v
npm -v

Esses comandos exibirão, respectivamente, as versões instaladas do Node.js e do NPM, confirmando que tudo está funcionando corretamente.

4. Criando um exemplo prático

Agora, com o Node.js e o npm instalados, vamos criar um simples servidor HTTP. Quando acessado, esse servidor responderá ao usuário a data e hora atual do sistema.

4.1 – Criação do código

Crie um novo arquivo onde você irá inserir o código abaixo e salve-o com o nome server.js:

// Importa o módulo 'http' para criar o servidor
const http = require('http');

// Define a porta em que o servidor vai escutar as requisições
const porta = 3000;

// Cria o servidor
const servidor = http.createServer((req, res) => {
  // Define o cabeçalho da resposta para indicar que o conteúdo é texto plano
  res.writeHead(200, { 'Content-Type': 'text/plain' });

  // Obtém a data e hora atuais
  const agora = new Date();

  // Envia a data e hora atuais como resposta
  res.end(`A data e a hora atuais são: ${agora}`);
});

// Inicia o servidor e o faz escutar na porta definida
servidor.listen(porta, () => {
  console.log(`Servidor rodando em http://localhost:${porta}/`);
});

4.2 – Execute o servidor

No terminal, vá até o diretório onde está o server.js e execute:

node server.js

Após executar o comando acima, você receberá essa mensagem em seu navegador: Servidor rodando em http://localhost:3000/

Agora, abra seu navegador e acesse: http://localhost:3000

Ao acessar o link acima, você verá na sua tela uma mensagem informando a data e hora atuais do seu computador.

Conclusão

O Node.js se consolidou como uma poderosa ferramenta para o desenvolvimento de aplicações modernas e escaláveis. Sua arquitetura não bloqueante, combinada com a popularidade do JavaScript e um vasto ecossistema de pacotes, torna-o ideal para criar desde simples servidores até sistemas complexos baseados em arquitetura de microsserviços.

Dominar essa ferramenta é um passo importante para qualquer desenvolvedor que deseje trabalhar com tecnologias atuais e de alto desempenho no back-end. O exemplo apresentado neste texto é apenas o começo — explorar mais profundamente essa plataforma certamente abrirá novas possibilidades e aprimorará suas habilidades como programador.

Espero que este conteúdo seja útil de alguma forma para você. Se gostou do conteúdo, compartilhe com seus amigos e aproveite para conhecer mais sobre programação aqui!