Linguagens de Programação

Um guia prático sobre as principais linguagens e suas aplicações no mercado

JavaScript

O que é?

JavaScript é a linguagem mais popular para desenvolvimento web, permitindo criar aplicações interativas e dinâmicas. É essencial para desenvolvimento front-end e, com Node.js, também é usado no back-end.

Principais Aplicações

  • Desenvolvimento de interfaces web modernas (React, Vue, Angular)
  • APIs e servidores com Node.js
  • Aplicativos móveis com React Native
  • Automação de tarefas e scripts

Mercado de Trabalho

JavaScript é uma das linguagens mais demandadas no mercado, com salários médios entre R$ 4.000 e R$ 12.000 para desenvolvedores júnior e pleno no Brasil.

Exemplo Prático: Sistema de Carrinho de Compras

class CarrinhoCompras {
    constructor() {
        this.itens = [];
        this.total = 0;
    }

    adicionarItem(produto, quantidade) {
        const item = {
            id: produto.id,
            nome: produto.nome,
            preco: produto.preco,
            quantidade: quantidade
        };
        
        const itemExistente = this.itens.find(i => i.id === produto.id);
        if (itemExistente) {
            itemExistente.quantidade += quantidade;
        } else {
            this.itens.push(item);
        }
        
        this.calcularTotal();
        this.salvarNoLocalStorage();
    }

    removerItem(id) {
        this.itens = this.itens.filter(item => item.id !== id);
        this.calcularTotal();
        this.salvarNoLocalStorage();
    }

    calcularTotal() {
        this.total = this.itens.reduce((total, item) => 
            total + (item.preco * item.quantidade), 0);
    }

    salvarNoLocalStorage() {
        localStorage.setItem('carrinho', JSON.stringify({
            itens: this.itens,
            total: this.total
        }));
    }

    carregarDoLocalStorage() {
        const dados = localStorage.getItem('carrinho');
        if (dados) {
            const { itens, total } = JSON.parse(dados);
            this.itens = itens;
            this.total = total;
        }
    }
}

// Exemplo de uso
const carrinho = new CarrinhoCompras();

// Adicionar produtos
carrinho.adicionarItem({
    id: 1,
    nome: "Smartphone XYZ",
    preco: 1999.99
}, 1);

carrinho.adicionarItem({
    id: 2,
    nome: "Capa Protetora",
    preco: 49.90
}, 2);

console.log('Itens no carrinho:', carrinho.itens);
console.log('Total:', carrinho.total.toFixed(2));

Python

O que é?

Python é uma linguagem versátil e de fácil aprendizado, amplamente utilizada em ciência de dados, automação, desenvolvimento web e inteligência artificial.

Principais Aplicações

  • Análise de dados e machine learning (Pandas, NumPy, TensorFlow)
  • Automação de processos e scripts
  • Desenvolvimento web (Django, Flask)
  • APIs e microsserviços

Mercado de Trabalho

Python é muito valorizado no mercado, especialmente em áreas de dados e IA. Salários médios variam de R$ 5.000 a R$ 15.000 para profissionais júnior e pleno.

Exemplo Prático: Sistema de Análise de Vendas

import pandas as pd
import matplotlib.pyplot as plt
from datetime import datetime, timedelta

class AnalisadorVendas:
    def __init__(self, arquivo_vendas):
        self.df = pd.read_csv(arquivo_vendas)
        self.df['data'] = pd.to_datetime(self.df['data'])
    
    def vendas_por_periodo(self, periodo='M'):
        """Analisa vendas por período (D=diário, M=mensal, A=anual)"""
        vendas = self.df.groupby(self.df['data'].dt.to_period(periodo))['valor'].sum()
        return vendas
    
    def produtos_mais_vendidos(self, top_n=5):
        """Retorna os produtos mais vendidos"""
        return self.df.groupby('produto')['quantidade'].sum().nlargest(top_n)
    
    def analise_tendencia(self, dias=30):
        """Analisa tendência de vendas nos últimos dias"""
        data_limite = datetime.now() - timedelta(days=dias)
        vendas_recentes = self.df[self.df['data'] >= data_limite]
        
        # Calcula média móvel de 7 dias
        vendas_diarias = vendas_recentes.groupby('data')['valor'].sum()
        media_movel = vendas_diarias.rolling(window=7).mean()
        
        return vendas_diarias, media_movel
    
    def gerar_relatorio(self, periodo='M'):
        """Gera relatório completo de vendas"""
        vendas = self.vendas_por_periodo(periodo)
        produtos = self.produtos_mais_vendidos()
        
        print(f"\n=== Relatório de Vendas ({periodo}) ===")
        print("\nVendas por período:")
        print(vendas)
        print("\nProdutos mais vendidos:")
        print(produtos)
        
        # Gera gráfico
        plt.figure(figsize=(12, 6))
        vendas.plot(kind='bar')
        plt.title('Vendas por Período')
        plt.xlabel('Período')
        plt.ylabel('Valor Total (R$)')
        plt.xticks(rotation=45)
        plt.tight_layout()
        plt.savefig('relatorio_vendas.png')

# Exemplo de uso
if __name__ == "__main__":
    # Dados de exemplo
    dados = {
        'data': pd.date_range(start='2024-01-01', periods=100, freq='D'),
        'produto': ['Produto A'] * 30 + ['Produto B'] * 40 + ['Produto C'] * 30,
        'quantidade': np.random.randint(1, 10, 100),
        'valor': np.random.uniform(50, 500, 100)
    }
    
    # Cria DataFrame de exemplo
    df = pd.DataFrame(dados)
    df.to_csv('vendas.csv', index=False)
    
    # Análise
    analisador = AnalisadorVendas('vendas.csv')
    analisador.gerar_relatorio('M')

C#

O que é?

C# é uma linguagem moderna e robusta desenvolvida pela Microsoft, ideal para desenvolvimento de aplicações empresariais, jogos e aplicativos Windows.

Principais Aplicações

  • Desenvolvimento de aplicações .NET
  • Jogos com Unity
  • APIs e microsserviços
  • Aplicativos desktop Windows

Mercado de Trabalho

C# é muito valorizado em empresas que usam tecnologias Microsoft. Salários médios variam de R$ 4.500 a R$ 13.000 para desenvolvedores júnior e pleno.

Exemplo Prático: Sistema de Gerenciamento de Projetos

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace GerenciadorProjetos
{
    public class Projeto
    {
        public int Id { get; set; }
        public string Nome { get; set; }
        public string Descricao { get; set; }
        public DateTime DataInicio { get; set; }
        public DateTime? DataFim { get; set; }
        public decimal Orcamento { get; set; }
        public StatusProjeto Status { get; set; }
        public List Tarefas { get; set; } = new List();
        public List Equipe { get; set; } = new List();
    }

    public class Tarefa
    {
        public int Id { get; set; }
        public string Titulo { get; set; }
        public string Descricao { get; set; }
        public DateTime DataCriacao { get; set; }
        public DateTime? DataConclusao { get; set; }
        public PrioridadeTarefa Prioridade { get; set; }
        public StatusTarefa Status { get; set; }
        public MembroEquipe Responsavel { get; set; }
    }

    public class MembroEquipe
    {
        public int Id { get; set; }
        public string Nome { get; set; }
        public string Email { get; set; }
        public string Cargo { get; set; }
        public List TarefasAtribuidas { get; set; } = new List();
    }

    public enum StatusProjeto { Planejamento, EmAndamento, Pausado, Concluido, Cancelado }
    public enum StatusTarefa { Pendente, EmAndamento, EmRevisao, Concluida }
    public enum PrioridadeTarefa { Baixa, Media, Alta, Urgente }

    public class GerenciadorProjetos
    {
        private List _projetos;
        private List _equipe;

        public GerenciadorProjetos()
        {
            _projetos = new List();
            _equipe = new List();
        }

        public async Task CriarProjeto(string nome, string descricao, decimal orcamento)
        {
            var projeto = new Projeto
            {
                Id = _projetos.Count + 1,
                Nome = nome,
                Descricao = descricao,
                DataInicio = DateTime.Now,
                Orcamento = orcamento,
                Status = StatusProjeto.Planejamento
            };

            _projetos.Add(projeto);
            await NotificarEquipe($"Novo projeto criado: {nome}");
            return projeto;
        }

        public async Task AdicionarTarefa(Projeto projeto, string titulo, string descricao, 
            PrioridadeTarefa prioridade, MembroEquipe responsavel)
        {
            var tarefa = new Tarefa
            {
                Id = projeto.Tarefas.Count + 1,
                Titulo = titulo,
                Descricao = descricao,
                DataCriacao = DateTime.Now,
                Prioridade = prioridade,
                Status = StatusTarefa.Pendente,
                Responsavel = responsavel
            };

            projeto.Tarefas.Add(tarefa);
            responsavel.TarefasAtribuidas.Add(tarefa);
            await NotificarMembro(responsavel, $"Nova tarefa atribuída: {titulo}");
        }

        public async Task AtualizarStatusTarefa(Tarefa tarefa, StatusTarefa novoStatus)
        {
            tarefa.Status = novoStatus;
            if (novoStatus == StatusTarefa.Concluida)
            {
                tarefa.DataConclusao = DateTime.Now;
                await NotificarEquipe($"Tarefa concluída: {tarefa.Titulo}");
            }
        }

        public async Task AtualizarStatusProjeto(Projeto projeto, StatusProjeto novoStatus)
        {
            projeto.Status = novoStatus;
            if (novoStatus == StatusProjeto.Concluido)
            {
                projeto.DataFim = DateTime.Now;
                await GerarRelatorioProjeto(projeto);
            }
        }

        private async Task NotificarEquipe(string mensagem)
        {
            // Simulação de envio de notificações
            await Task.Delay(100);
            Console.WriteLine($"Notificação para equipe: {mensagem}");
        }

        private async Task NotificarMembro(MembroEquipe membro, string mensagem)
        {
            // Simulação de envio de notificação
            await Task.Delay(100);
            Console.WriteLine($"Notificação para {membro.Nome}: {mensagem}");
        }

        private async Task GerarRelatorioProjeto(Projeto projeto)
        {
            var relatorio = new
            {
                Projeto = projeto.Nome,
                DataInicio = projeto.DataInicio,
                DataFim = projeto.DataFim,
                Duracao = (projeto.DataFim - projeto.DataInicio)?.TotalDays,
                TotalTarefas = projeto.Tarefas.Count,
                TarefasConcluidas = projeto.Tarefas.Count(t => t.Status == StatusTarefa.Concluida),
                OrcamentoUtilizado = projeto.Tarefas
                    .Where(t => t.Status == StatusTarefa.Concluida)
                    .Sum(t => t.Responsavel.Cargo == "Senior" ? 1000 : 500)
            };

            Console.WriteLine("\n=== Relatório do Projeto ===");
            Console.WriteLine($"Projeto: {relatorio.Projeto}");
            Console.WriteLine($"Duração: {relatorio.Duracao} dias");
            Console.WriteLine($"Tarefas: {relatorio.TarefasConcluidas}/{relatorio.TotalTarefas}");
            Console.WriteLine($"Orçamento utilizado: R$ {relatorio.OrcamentoUtilizado}");
        }
    }

    class Program
    {
        static async Task Main(string[] args)
        {
            var gerenciador = new GerenciadorProjetos();

            // Criar membros da equipe
            var joao = new MembroEquipe { Id = 1, Nome = "João Silva", Email = "joao@empresa.com", Cargo = "Senior" };
            var maria = new MembroEquipe { Id = 2, Nome = "Maria Santos", Email = "maria@empresa.com", Cargo = "Junior" };

            // Criar projeto
            var projeto = await gerenciador.CriarProjeto(
                "Sistema de Vendas Online",
                "Desenvolvimento de plataforma e-commerce",
                50000
            );

            // Adicionar tarefas
            await gerenciador.AdicionarTarefa(
                projeto,
                "Implementar carrinho de compras",
                "Desenvolver funcionalidade de carrinho com persistência",
                PrioridadeTarefa.Alta,
                joao
            );

            await gerenciador.AdicionarTarefa(
                projeto,
                "Criar interface do usuário",
                "Desenvolver telas principais do sistema",
                PrioridadeTarefa.Media,
                maria
            );

            // Simular conclusão de tarefas
            var tarefa = projeto.Tarefas.First();
            await gerenciador.AtualizarStatusTarefa(tarefa, StatusTarefa.Concluida);

            // Finalizar projeto
            await gerenciador.AtualizarStatusProjeto(projeto, StatusProjeto.Concluido);
        }
    }
}

Java

O que é?

Java é uma linguagem robusta e madura, amplamente utilizada em aplicações empresariais, sistemas bancários e desenvolvimento Android.

Principais Aplicações

  • Desenvolvimento de aplicações empresariais
  • Aplicativos Android
  • Sistemas bancários e financeiros
  • Microsserviços e APIs

Mercado de Trabalho

Java é muito valorizado em grandes empresas e bancos. Salários médios variam de R$ 4.000 a R$ 14.000 para desenvolvedores júnior e pleno.

Exemplo Prático: Sistema Bancário

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.*;
import java.util.concurrent.locks.ReentrantLock;

public class SistemaBancario {
    private Map contas;
    private Map clientes;
    private List transacoes;
    private ReentrantLock lock;

    public SistemaBancario() {
        this.contas = new HashMap<>();
        this.clientes = new HashMap<>();
        this.transacoes = new ArrayList<>();
        this.lock = new ReentrantLock();
    }

    public class Cliente {
        private String cpf;
        private String nome;
        private String email;
        private List contas;
        private LocalDateTime dataCadastro;

        public Cliente(String cpf, String nome, String email) {
            this.cpf = cpf;
            this.nome = nome;
            this.email = email;
            this.contas = new ArrayList<>();
            this.dataCadastro = LocalDateTime.now();
        }

        // Getters e setters
    }

    public class Conta {
        private String numero;
        private String agencia;
        private Cliente titular;
        private BigDecimal saldo;
        private TipoConta tipo;
        private List historico;
        private boolean ativa;

        public Conta(String numero, String agencia, Cliente titular, TipoConta tipo) {
            this.numero = numero;
            this.agencia = agencia;
            this.titular = titular;
            this.saldo = BigDecimal.ZERO;
            this.tipo = tipo;
            this.historico = new ArrayList<>();
            this.ativa = true;
        }

        public void depositar(BigDecimal valor) {
            if (valor.compareTo(BigDecimal.ZERO) <= 0) {
                throw new IllegalArgumentException("Valor do depósito deve ser positivo");
            }
            this.saldo = this.saldo.add(valor);
            registrarTransacao(TipoTransacao.DEPOSITO, valor);
        }

        public void sacar(BigDecimal valor) {
            if (valor.compareTo(BigDecimal.ZERO) <= 0) {
                throw new IllegalArgumentException("Valor do saque deve ser positivo");
            }
            if (valor.compareTo(this.saldo) > 0) {
                throw new SaldoInsuficienteException("Saldo insuficiente para saque");
            }
            this.saldo = this.saldo.subtract(valor);
            registrarTransacao(TipoTransacao.SAQUE, valor);
        }

        private void registrarTransacao(TipoTransacao tipo, BigDecimal valor) {
            Transacao transacao = new Transacao(this, tipo, valor);
            this.historico.add(transacao);
            SistemaBancario.this.transacoes.add(transacao);
        }

        public void transferir(Conta destino, BigDecimal valor) {
            if (!this.ativa || !destino.ativa) {
                throw new ContaInativaException("Conta inativa");
            }
            if (valor.compareTo(BigDecimal.ZERO) <= 0) {
                throw new IllegalArgumentException("Valor da transferência deve ser positivo");
            }
            if (valor.compareTo(this.saldo) > 0) {
                throw new SaldoInsuficienteException("Saldo insuficiente para transferência");
            }

            lock.lock();
            try {
                this.saldo = this.saldo.subtract(valor);
                destino.saldo = destino.saldo.add(valor);
                
                Transacao transacao = new Transacao(this, destino, valor);
                this.historico.add(transacao);
                destino.historico.add(transacao);
                SistemaBancario.this.transacoes.add(transacao);
            } finally {
                lock.unlock();
            }
        }

        public List getExtrato(LocalDateTime inicio, LocalDateTime fim) {
            return this.historico.stream()
                .filter(t -> t.getData().isAfter(inicio) && t.getData().isBefore(fim))
                .toList();
        }
    }

    public class Transacao {
        private String id;
        private Conta origem;
        private Conta destino;
        private BigDecimal valor;
        private TipoTransacao tipo;
        private LocalDateTime data;
        private StatusTransacao status;

        public Transacao(Conta origem, Conta destino, BigDecimal valor) {
            this.id = UUID.randomUUID().toString();
            this.origem = origem;
            this.destino = destino;
            this.valor = valor;
            this.tipo = TipoTransacao.TRANSFERENCIA;
            this.data = LocalDateTime.now();
            this.status = StatusTransacao.CONCLUIDA;
        }

        public Transacao(Conta conta, TipoTransacao tipo, BigDecimal valor) {
            this.id = UUID.randomUUID().toString();
            this.origem = tipo == TipoTransacao.SAQUE ? conta : null;
            this.destino = tipo == TipoTransacao.DEPOSITO ? conta : null;
            this.valor = valor;
            this.tipo = tipo;
            this.data = LocalDateTime.now();
            this.status = StatusTransacao.CONCLUIDA;
        }

        // Getters
    }

    public enum TipoConta { CORRENTE, POUPANCA, INVESTIMENTO }
    public enum TipoTransacao { DEPOSITO, SAQUE, TRANSFERENCIA }
    public enum StatusTransacao { PENDENTE, CONCLUIDA, CANCELADA, FALHA }

    public class SaldoInsuficienteException extends RuntimeException {
        public SaldoInsuficienteException(String message) {
            super(message);
        }
    }

    public class ContaInativaException extends RuntimeException {
        public ContaInativaException(String message) {
            super(message);
        }
    }

    // Métodos do Sistema Bancário
    public Cliente cadastrarCliente(String cpf, String nome, String email) {
        if (clientes.containsKey(cpf)) {
            throw new IllegalArgumentException("Cliente já cadastrado");
        }
        Cliente cliente = new Cliente(cpf, nome, email);
        clientes.put(cpf, cliente);
        return cliente;
    }

    public Conta abrirConta(Cliente cliente, TipoConta tipo) {
        String numero = gerarNumeroConta();
        String agencia = "0001";
        Conta conta = new Conta(numero, agencia, cliente, tipo);
        contas.put(numero, conta);
        cliente.contas.add(conta);
        return conta;
    }

    private String gerarNumeroConta() {
        return String.format("%06d", new Random().nextInt(1000000));
    }

    public void realizarTransferencia(String contaOrigem, String contaDestino, BigDecimal valor) {
        Conta origem = contas.get(contaOrigem);
        Conta destino = contas.get(contaDestino);

        if (origem == null || destino == null) {
            throw new IllegalArgumentException("Conta não encontrada");
        }

        origem.transferir(destino, valor);
    }

    public List consultarExtrato(String numeroConta, LocalDateTime inicio, LocalDateTime fim) {
        Conta conta = contas.get(numeroConta);
        if (conta == null) {
            throw new IllegalArgumentException("Conta não encontrada");
        }
        return conta.getExtrato(inicio, fim);
    }

    public static void main(String[] args) {
        SistemaBancario banco = new SistemaBancario();

        try {
            // Cadastrar cliente
            Cliente cliente = banco.cadastrarCliente(
                "123.456.789-00",
                "João Silva",
                "joao@email.com"
            );

            // Abrir conta
            Conta conta = banco.abrirConta(cliente, TipoConta.CORRENTE);

            // Realizar operações
            conta.depositar(new BigDecimal("1000.00"));
            conta.sacar(new BigDecimal("200.00"));

            // Abrir conta poupança
            Conta poupanca = banco.abrirConta(cliente, TipoConta.POUPANCA);
            poupanca.depositar(new BigDecimal("500.00"));

            // Realizar transferência
            banco.realizarTransferencia(
                conta.numero,
                poupanca.numero,
                new BigDecimal("300.00")
            );

            // Consultar extrato
            LocalDateTime inicio = LocalDateTime.now().minusDays(1);
            LocalDateTime fim = LocalDateTime.now();
            List extrato = banco.consultarExtrato(conta.numero, inicio, fim);

            System.out.println("Extrato da conta " + conta.numero + ":");
            extrato.forEach(t -> System.out.println(
                t.getData() + " - " + t.getTipo() + " - R$ " + t.getValor()
            ));

        } catch (Exception e) {
            System.err.println("Erro: " + e.getMessage());
        }
    }
}

p5.js

O que é?

p5.js é uma biblioteca JavaScript que torna a programação criativa e visual mais acessível, ideal para criar arte interativa, visualizações e jogos no navegador.

Principais Aplicações

  • Arte generativa e interativa
  • Visualização de dados
  • Jogos e simulações
  • Instalações interativas

Mercado de Trabalho

p5.js é valorizado em áreas criativas e educacionais. Profissionais que combinam p5.js com outras tecnologias web podem ganhar entre R$ 3.500 e R$ 8.000.

Exemplo Prático: Visualizador de Partículas Interativo

// Sistema de partículas interativo
let particles = [];
const maxParticles = 200;
let hue = 0;

function setup() {
    createCanvas(windowWidth, windowHeight);
    colorMode(HSB, 360, 100, 100, 1);
    background(0);
    
    // Criar partículas iniciais
    for (let i = 0; i < maxParticles; i++) {
        particles.push(new Particle());
    }
}

function draw() {
    // Efeito de fade
    background(0, 0, 0, 0.1);
    
    // Atualizar e mostrar partículas
    for (let particle of particles) {
        particle.update();
        particle.show();
    }
    
    // Adicionar novas partículas no mouse
    if (mouseIsPressed && particles.length < maxParticles) {
        particles.push(new Particle(mouseX, mouseY));
    }
    
    // Remover partículas antigas
    particles = particles.filter(p => p.life > 0);
    
    // Atualizar cor
    hue = (hue + 0.5) % 360;
}

class Particle {
    constructor(x, y) {
        this.pos = createVector(x || random(width), y || random(height));
        this.vel = p5.Vector.random2D().mult(random(1, 3));
        this.acc = createVector(0, 0);
        this.size = random(2, 8);
        this.life = 255;
        this.color = color(hue, 80, 100, 0.8);
    }
    
    update() {
        // Atualizar posição
        this.vel.add(this.acc);
        this.pos.add(this.vel);
        this.acc.mult(0);
        
        // Aplicar atrito
        this.vel.mult(0.98);
        
        // Reduzir vida
        this.life -= 2;
        
        // Verificar bordas
        if (this.pos.x < 0 || this.pos.x > width) {
            this.vel.x *= -1;
        }
        if (this.pos.y < 0 || this.pos.y > height) {
            this.vel.y *= -1;
        }
        
        // Interação com o mouse
        if (mouseIsPressed) {
            let mouse = createVector(mouseX, mouseY);
            let dir = p5.Vector.sub(mouse, this.pos);
            let d = dir.mag();
            
            if (d < 100) {
                dir.normalize();
                dir.mult(0.5);
                this.acc.add(dir);
            }
        }
    }
    
    show() {
        noStroke();
        fill(hue, 80, 100, this.life / 255);
        circle(this.pos.x, this.pos.y, this.size);
        
        // Adicionar brilho
        fill(hue, 40, 100, this.life / 510);
        circle(this.pos.x, this.pos.y, this.size * 2);
    }
}

// Ajustar canvas quando a janela for redimensionada
function windowResized() {
    resizeCanvas(windowWidth, windowHeight);
}

// Adicionar partículas com clique
function mousePressed() {
    for (let i = 0; i < 5; i++) {
        if (particles.length < maxParticles) {
            particles.push(new Particle(mouseX, mouseY));
        }
    }
}