Planejamento de Ensino: Fundamentos da Computação e Arquitetura

Carga Horária Total: 20 Horas

Duração: 3 Semanas (Semanas 1 e 2 com 8h; Semana 3 com 4h)

Ementa: A Base Binária, Octal, Decimal e Hexadecimal. História dos computadores, as quatro gerações. Arquitetura de John Von Neumann. Os componentes de um computador. As Instruções de máquina. A Tradução de instruções de máquina.

Semana 1: A Evolução e a Língua da Máquina (8 Horas)

Objetivo: Mostrar a história por trás do código e desmistificar os números binários de forma visual e interativa.

• Tópicos:

  • História (Breve): Das pedrinhas no chão (Ábaco) ao smartphone. As 4 gerações e os heróis Ada Lovelace e Alan Turing.

  • Hardware vs. Software: O hardware é o instrumento; o software é a música.

  • A Língua da Máquina: Como o computador só entende "Ligado" (1) e "Desligado" (0). Conversão rápida entre Bases (Binária, Decimal e Hexadecimal).

• Dinâmicas (Trabalho em Equipe):

  • O Computador Humano: O "Programador" escreve instruções num papel, o "Processador" lê e o "Hardware" (vendado) executa (ex: "Ande 2 passos").

  • Mensagem Criptografada: Com uma Tabela ASCII simples, os alunos escrevem uma frase em binário (0 e 1) e trocam com outra equipe para traduzirem.

• Exercícios de Fixação:

  • Se você fosse criar um robô para fazer um café, quais seriam as 3 primeiras instruções?

  • Transforme o número 10 (decimal) em binário usando a técnica das "lâmpadas acesas".

Semana 2: A Arquitetura e o Idioma do Chefe (8 Horas)

Objetivo: Entender as peças do PC usando a analogia de um escritório e como a CPU executa as ordens.

• Tópicos:

  • Arquitetura de Von Neumann (A Analogia do Escritório):

    • CPU (Chefe): Toma decisões e faz as contas.

    • RAM (Mesa de Trabalho): Onde ficam as coisas que estão sendo usadas agora.

    • HD/SSD (Arquivo): O armário que guarda tudo quando o escritório fecha.

    • Entrada e Saída: Teclado (ordens) e Monitor (resultado).

  • Instruções de Máquina: Como o processador busca, entende e executa uma ordem básica (Somar, Mover).

• Dinâmicas (Trabalho em Equipe):

  • Gincana "Monte seu PC": Espalhe cartões com nomes de peças (RAM, CPU, Teclado). A equipe que agrupar mais rápido o que é Memória, Processamento ou Entrada/Saída ganha o jogo.

• Exercícios de Fixação:

  • Se um programa está "travando", o problema costuma estar na Mesa (RAM) ou no Armário (HD)?

  • Cite um dispositivo que é de Entrada e Saída ao mesmo tempo.

Semana 3: A Tradução e o Futuro (4 Horas)

Objetivo: Explicar como a nossa linguagem vira código e fechar a disciplina com inspiração.

• Tópicos:

  • A Tradução (Compiladores): Por que inventamos linguagens fáceis (PHP, Python, Java)? Explicar que os compiladores são os "tradutores simultâneos" entre o Programador e a CPU.

• Prática e Avaliação Final:

  • Roda de Conversa: "Agora que sabemos como a máquina funciona, que tipo de programa ou app você sonha em criar?"

  • Apresentação Final: Criação de um cartaz ou "Manual Simplificado" da equipe, explicando para um leigo como o Processador e a Memória trabalham juntos para abrir o WhatsApp.

Metodologia de Avaliação Sugerida

Atividade

Descrição

Peso

Gincanas e Dinâmicas (Semanas 1 e 2)

Engajamento nas brincadeiras (Computador Humano, Mensagem Criptografada e Montagem do PC).

40%

Caderno de Fixação (Semana 1 e 2)

Resolução das perguntas reflexivas e conversão binária na prática.

20%

Manual do Computador (Semana 3)

Entrega e apresentação do manual/cartaz simplificando a arquitetura do PC para leigos.

40%

Carga Horária Total: 60 Horas

Duração: 8 Semanas (7,5 horas por semana)

Ementa: Estudo dos fundamentos da Inteligência Artificial, suas tipologias e funcionamento, com foco aplicado no design, produção e implementação de chatbots para resolução de problemas.

Semana 1: Fundamentos da Inteligência

Objetivo: Compreender as bases biológicas e filosóficas da inteligência e como elas se traduzem para o campo computacional.

Tópicos:

• O que é Inteligência? (Humana vs. Artificial).

• Breve história da IA: Do Teste de Turing aos modelos atuais.

• Conceitos de Agentes Inteligentes.

• Ética na IA: Viés, privacidade e o impacto social.

Semana 2: Tipos e Funcionamento da IA

Objetivo: Diferenciar as diversas categorias de IA e entender a lógica por trás do aprendizado de máquina.

Tópicos:

• IA Estreita (ANI), IA Geral (AGI) e Superinteligência (ASI).

• IA Simbólica (Baseada em regras) vs. IA Conexionista (Redes Neurais).

• Introdução ao Machine Learning: Supervisionado, Não Supervisionado e por Reforço.

• O papel dos Dados: Coleta, limpeza e importância para o treinamento.

Shutterstock
Explorar

Semana 3: Processamento de Linguagem Natural (PLN)

Objetivo: Entender como as máquinas interpretam, processam e geram a linguagem humana.

Tópicos:

• Conceitos de NLP (Natural Language Processing).

• Tokenização, Stemming e Lemmatization.

• Análise de Sentimento e Reconhecimento de Entidades Nomeadas (NER).

• Introdução aos LLMs (Large Language Models) e IA Generativa.

Semana 4: Ecossistema dos Chatbots

Objetivo: Mapear o mercado de chatbots e identificar as tecnologias disponíveis para diferentes necessidades.

Tópicos:

• Evolução dos Chatbots: De ELIZA aos assistentes modernos (GPT, Claude, Gemini).

• Chatbots de Fluxo (Baseados em regras) vs. Chatbots Cognitivos (IA).

• Canais de Atendimento: WhatsApp, Web, Telegram e Integrações.

• Casos de uso: Atendimento ao cliente, Vendas, Saúde e Educação.

Semana 5: Design de Conversação (UX Writing)

Objetivo: Planejar a interação entre humano e máquina com foco na experiência do usuário.

Tópicos:

• Definição de Persona: Tom de voz e personalidade do bot.

• Mapeamento de Jornada do Usuário.

• Design de Fluxo: Fluxogramas de conversação e caminhos felizes/críticos.

• Boas práticas de escrita para interfaces conversacionais.

Semana 6: Produção e Ferramentas (Mão na Massa)

Objetivo: Aprender a utilizar ferramentas de criação (Low-code e No-code) para construir a estrutura do bot.

Tópicos:

• Arquitetura de um Chatbot: Intenções (Intents), Entidades e Frases de Treinamento.

• Exploração de Ferramentas (ex: Dialogflow, Typebot, Blip ou Rasa).

• Configuração de respostas dinâmicas e variáveis.

• Integração com APIs externas (Consultando dados externos).

Semana 7: Inteligência Generativa e Prompt Engineering

Objetivo: Potencializar chatbots utilizando modelos de linguagem avançados através de prompts eficientes.

Tópicos:

• O que é um Prompt e como estruturá-lo (Contexto, Tarefa, Restrições).

• Técnicas de Few-shot e Chain-of-Thought prompting.

• Conectando o Chatbot a uma base de conhecimento própria (RAG - Retrieval-Augmented Generation).

• Alucinação em IAs e como mitigá-la.

Semana 8: Prática Integrada e Projeto Final

Objetivo: Consolidar o aprendizado através da criação de uma solução funcional.

Tópicos:

• Testes e Curadoria: Como treinar e melhorar o bot após o lançamento.

• Métricas de Sucesso: Taxa de retenção, transbordo humano e CSAT.

• Projeto Final: Desenvolvimento de um protótipo de chatbot funcional focado em resolver um problema real (ex: Agendamento médico, FAQ inteligente ou Assistente de estudos).

Metodologia de Avaliação Sugerida

Atividade                                                       Descrição                                                                                                Peso

Atividades Semanais                                    Questionários teóricos e exercícios de lógica de IA.                               20%

Mapa de Fluxo                                               Desenho da árvore de decisão e persona de um chatbot.                      30%

Projeto Final                                                  Protótipo funcional do chatbot + Documentação do design.                    50%

Carga Horária Total: 40 Horas

Duração: 5 Semanas (8 horas por semana)

Ementa: Fundamentos da lógica de programação para o desenvolvimento de softwares.

Semana 1: Introdução ao Pensamento Computacional

• Objetivo: Compreender como decompor problemas e transformá-los em passos lógicos.

• Tópicos:

  • O que é um Algoritmo e sua importância no desenvolvimento de software.

  • Formas de representação: Fluxogramas, Pseudocódigo (Portugol) e Descrição Narrativa.

  • Tipos de dados primitivos: Inteiro, Real, Caractere e Booleano.

  • Variáveis e Constantes: Declaração, atribuição e regras de nomenclatura.

  • Operadores Aritméticos e precedência matemática.

Semana 2: Estruturas de Decisão (Condicionais)

• Objetivo: Capacitar o software a tomar decisões baseadas em condições específicas.

• Tópicos:

  • Expressões Lógicas e Operadores Relacionais (>, <, ==, !=).

  • Operadores Lógicos: E (AND), OU (OR) e NÃO (NOT).

  • Estrutura condicional simples: SE (IF).

  • Estrutura condicional composta: SE / SENÃO (IF / ELSE).

  • Estruturas encadeadas e o comando ESCOLHA / CASO (SWITCH / CASE).

Semana 3: Estruturas de Repetição (Laços de Repetição)

• Objetivo: Automatizar tarefas repetitivas e otimizar o processamento de dados.

• Tópicos:

  • Conceito de Iteração.

  • Laço com teste no início: ENQUANTO (WHILE).

  • Laço com teste no fim: FAÇA...ENQUANTO (DO...WHILE).

  • Laço com variável de controle: PARA (FOR).

  • Contadores e Acumuladores.

Semana 4: Estruturas de Dados Básicas (Vetores e Matrizes)

• Objetivo: Manipular múltiplos valores sob um único nome de variável de forma organizada.

• Tópicos:

  • Variáveis Compostas Unidimensionais (Vetores): Declaração, indexação e percurso.

  • Manipulação de strings como vetores de caracteres.

  • Variáveis Compostas Multidimensionais (Matrizes): Conceito de linhas e colunas.

  • Operações básicas: Leitura, escrita e busca em vetores.

Semana 5: Modularização e Prática Integrada

• Objetivo: Organizar o código em blocos reutilizáveis e aplicar o conhecimento em um projeto final.

• Tópicos:

  • Conceito de Sub-rotinas: Procedimentos e Funções.

  • Passagem de parâmetros e retorno de valores.

  • Escopo de variáveis (Global vs. Local).

  • Projeto Final: Desenvolvimento de um algoritmo completo (ex: Sistema de Gerenciamento Escolar ou Controle de Estoque simplificado) integrando todos os tópicos do curso.

Metodologia de Avaliação Sugerida

Atividade

Descrição                                                                                                                            Peso                                                           Exercícios Práticos

• Listas de resolução de problemas semanais em pseudocódigo.                                     30%                                                           Desafios de Lógica

• Pequenos testes de mesa para validar a execução de algoritmos.                                 20%                                                            Projeto Final

• Desenvolvimento de uma solução algorítmica documentada para um problema real.    50%

Carga Horária Total: 40 Horas

Duração: 5 Semanas (8 horas por semana)

Ementa: Estudo dos pilares da segurança da informação, ameaças cibernéticas, criptografia, ferramentas de defesa e estratégias de proteção e controle de dados.

Semana 1: Fundamentos e os Pilares da Segurança

Objetivo: Compreender os conceitos básicos que sustentam a proteção de dados e a ética na segurança.

Tópicos:

• O Triângulo CIA: Confidencialidade, Integridade e Disponibilidade.

• Autenticidade e Irretratabilidade (Não-repúdio): Garantindo a autoria das ações.

• Segurança Física vs. Segurança Lógica.

• Engenharia Social: O fator humano como elo mais fraco da corrente.

• Introdução à LGPD (Lei Geral de Proteção de Dados).

Semana 2: Ameaças e Vulnerabilidades (Malwares)

Objetivo: Identificar os principais riscos e tipos de softwares maliciosos que comprometem sistemas.

Tópicos:

• Diferença entre Vírus, Worms e Cavalos de Troia (Trojans).

• Ameaças Modernas: Ransomware (sequestro de dados) e Spywares.

• Phishing e técnicas de infiltração.

• Vulnerabilidades de software: O que são exploits e ataques Zero-day.

• Análise de casos reais de vazamento de dados.

Semana 3: Criptografia e Certificação Digital

Objetivo: Entender como a matemática protege a informação através da codificação.

Tópicos:

• História da Criptografia: Da Cifra de César aos dias atuais.

• Criptografia Simétrica vs. Assimétrica: Chaves públicas e privadas.

• Funções Hash: Garantindo a integridade dos arquivos.

• Certificados Digitais e Protocolos de Comunicação Segura (HTTPS/SSL/TLS).

• Assinatura Digital: Como validar documentos eletrônicos.

Shutterstock

Semana 4: Mecanismos de Defesa e Controle de Acesso

Objetivo: Aplicar ferramentas e regras para monitorar, filtrar e restringir o acesso a informações.

Tópicos:

• Firewalls: Tipos, funções e regras de filtragem de pacotes.

• Sistemas de Detecção e Prevenção de Intrusão (IDS e IPS).

• Controle de Acesso: Identificação, Autenticação (MFA - Múltiplo Fator) e Autorização.

• Princípio do Menor Privilégio (PoLP).

• VPNs (Virtual Private Networks): Criando túneis seguros em redes públicas.

Shutterstock
Explorar

Semana 5: Gestão de Incidentes e Prática Integrada

Objetivo: Criar planos de resposta a falhas e aplicar o conhecimento em uma auditoria prática.

Tópicos:

• Backup e Recuperação de Desastres (Disaster Recovery).

• Políticas de Segurança da Informação (PSI): Como criar regras para empresas.

• Identificação e correção de falhas de segurança comuns.

• Projeto Final: Auditoria de segurança simplificada em um cenário fictício (identificar vulnerabilidades e propor medidas preventivas e corretivas).

Metodologia de Avaliação Sugerida

Atividade                                                    Descrição                                                                                                                                       Peso

Quiz Semanal                                             Testes rápidos sobre conceitos de malwares e pilares da segurança.                                           20%

Laboratório Prático                                   Simulação de configuração de senhas fortes, MFA e análise de e-mails suspeitos.                      30%

Projeto Final                                              Elaboração de um Plano de Segurança (PSI) e resolução de um estudo de caso de ataque.       50% 

Planejamento de Ensino: Introdução à Programação

Carga Horária Total: 40 Horas

Duração: 5 Semanas (8 horas por semana, 2 encontros de 4h)

Ementa: Algoritmos; conceito de linguagem de programação. Operações de entrada e saída. Operação de atribuição. Tipos, variáveis e constantes. Desvios condicionais. Comandos de seleção múltipla. Estruturas de repetição. Vetores e matrizes. Modularização de programas.

Semana 1: O Caminho das Pedras - Algoritmos e Dados

Objetivo: Tirar o aluno do pensamento humano e levá-lo para o pensamento computacional (passo a passo), entendendo como a máquina guarda informações.

• Tópicos (Ementa): Algoritmos, conceito de linguagem, entrada/saída, atribuição, tipos, variáveis e constantes.

• Detalhamento:

  • Algoritmos: O que são? A lógica da "receita de bolo" e o passo a passo sequencial.

  • Linguagens de Programação: Como conversamos com a máquina (código fonte vs. interpretador/compilador).

  • Memória do Computador: O que são Variáveis (caixas que mudam) e Constantes (caixas fixas).

  • Tipos de Dados: Inteiro, Real (Float), Caractere/Texto (String) e Lógico (Booleano).

  • Comandos Básicos: Atribuição (guardar valor), Entrada (Ler/Input) e Saída (Escrever/Print).

  • Prática: Criar algoritmos sequenciais (ex: calcular a média de 3 notas de um aluno e imprimir o resultado na tela).

Semana 2: Ensinando o Computador a Escolher (Condicionais)

Objetivo: Fazer o programa tomar decisões baseadas em regras de negócio, usando lógica matemática.

• Tópicos (Ementa): Desvios condicionais e comandos de seleção múltipla.

• Detalhamento:

  • Desvio Condicional Simples e Composto: Estrutura SE / SENÃO (IF / ELSE).

  • Operadores Relacionais e Lógicos: Maior, menor, igual, diferente, E (AND), OU (OR).

  • Condicionais Aninhadas: Um IF dentro de outro IF.

  • Seleção Múltipla: Estrutura ESCOLHA / CASO (SWITCH / CASE) para menus e opções exatas.

  • Prática: Criar um sistema de caixa de supermercado onde o algoritmo aplica um desconto diferente dependendo da forma de pagamento (Dinheiro, Cartão, Pix).

Semana 3: Automatizando o Trabalho (Estruturas de Repetição)

Objetivo: Compreender que o computador é perfeito para tarefas repetitivas e aprender a não duplicar código.

• Tópicos (Ementa): Estruturas de repetição.

• Detalhamento:

  • O Conceito de Laço (Loop): Como repetir um bloco de código de forma controlada.

  • Laço com Teste Lógico no Início: Estrutura ENQUANTO (WHILE).

  • Laço com Teste Lógico no Final: Estrutura REPITA ou FAÇA-ENQUANTO (DO-WHILE).

  • Laço com Variável de Controle: Estrutura PARA (FOR).

  • Prática: Criar um algoritmo que pede a senha do usuário e repete a pergunta até que ele acerte, ou um programa que imprima a tabuada de qualquer número de 1 a 10.

Semana 4: Organizando Múltiplos Dados (Vetores e Matrizes)

Objetivo: Permitir que o aluno guarde várias informações do mesmo tipo sem precisar criar dezenas de variáveis isoladas.

• Tópicos (Ementa): Vetores e matrizes.

• Detalhamento:

  • Vetores (Arrays Unidimensionais): Listas de variáveis. Como declarar, preencher e ler usando laços de repetição (FOR).

  • Índices: Entendendo que na programação a contagem começa do zero.

  • Matrizes (Arrays Multidimensionais): Tabelas com linhas e colunas.

  • Prática: Fazer um programa que leia e guarde o nome de 10 alunos usando um único vetor, e depois imprima apenas os que começam com a letra "A"; ou criar a grade de um Jogo da Velha simples usando uma matriz 3x3.

Semana 5: Limpando a Casa e Projeto Integrador (Modularização)

Objetivo: Aprender a organizar sistemas maiores quebrando-os em pequenos blocos reaproveitáveis.

• Tópicos (Ementa): Modularização de programas.

• Detalhamento:

  • Dividir para Conquistar: Por que não escrever tudo no fluxo principal do programa.

  • Funções (Retornam valor) e Procedimentos/Métodos (Não retornam valor).

  • Passagem de Parâmetros: Como enviar dados para dentro de uma função.

  • Escopo: Variáveis Locais (nascem e morrem na função) vs. Variáveis Globais.

  • Prática (Projeto Final): Criar um "Mini Sistema de Caixa Eletrônico" que rola no terminal/console. O sistema deve ter um menu principal (SWITCH), funções modulares para Sacar(), Depositar() e VerSaldo(), repetindo (WHILE) até o usuário escolher a opção "Sair".

Metodologia de Avaliação Sugerida

Atividade                                                                    Descrição                                                                                                                  Peso

Bateria de Lógica (Semanas 1 e 2)                          Lista de exercícios práticos focada na criação de algoritmos sequenciais                                                                                                                                     e uso correto do IF/ELSE para resolver problemas lógicos.                                      20%

Laboratório de Loops e Arrays (Semanas 3 e 4)    Avaliação prática em sala onde o aluno deve criar laços de repetição para                                                                                                                                   percorrer vetores e processar dados (ex: achar o maior número em uma lista).       30%

Projeto Final Modular (Semana 5)                           Entrega do "Mini Sistema" rodando sem erros, exigindo que o aluno aplique                                                                                                                               modularização (Funções), repetição para manter o programa ativo e                                                                                                                                           variáveis/arrays para controlar os dados.                                                                   50%

Planejamento de Ensino: Redes de Computadores

Carga Horária Total: 40 Horas

Duração: 5 Semanas (8 horas por semana)

Ementa: Estudo dos modelos de referência, protocolos de comunicação, endereçamento IP, serviços de rede e configuração de servidores para disponibilização de aplicações.

Semana 1: Fundamentos e Arquitetura de Redes

Objetivo: Entender como os dados viajam e como as redes são organizadas logicamente.

• Tópicos:

  • Modelos de Referência: O Modelo OSI (7 camadas) e o Modelo TCP/IP.

  • Topologias e Tipos de Redes: LAN, WAN, WLAN e topologias físicas/lógicas.

  • Equipamentos de Rede: Funções de Hubs, Switches e Roteadores.

  • Meios de Transmissão: Cabos par trançado, fibra óptica e redes sem fio.

  • Protocolos de Enlace: Endereçamento físico (MAC Address).

Semana 2: Endereçamento e Protocolos de Transporte

Objetivo: Dominar a identificação de dispositivos na rede e a entrega confiável de pacotes.

• Tópicos:

  • Endereçamento IPv4: Classes, máscaras de rede e sub-redes básicas.

  • Introdução ao IPv6: Por que mudar e principais diferenças.

  • Protocolos de Transporte: TCP (Confiável) vs. UDP (Rápido).

  • Portas e Sockets: Como as aplicações se identificam na rede (Portas 80, 443, 3306, etc.).

  • Prática: Comandos de diagnóstico (Ping, Tracert, Ipconfig/Ifconfig).

Semana 3: Serviços de Rede e Infraestrutura

Objetivo: Compreender os serviços essenciais que fazem a internet e as redes locais funcionarem.

• Tópicos:

  • DNS (Domain Name System): Resolução de nomes para IPs.

  • DHCP: Atribuição automática de endereços.

  • Protocolo HTTP/HTTPS: A base da comunicação web.

  • FTP e SSH: Transferência de arquivos e acesso remoto seguro.

  • Prática: Simulação de redes simples no Cisco Packet Tracer ou software similar.

Semana 4: Criação e Configuração de Servidores

Objetivo: Preparar o ambiente para disponibilizar aplicações desenvolvidas pelos alunos.

• Tópicos:

  • Conceito de Cliente-Servidor: Onde os dados residem.

  • Servidores Web: Instalação e configuração básica (Apache ou Nginx).

  • Servidores de Aplicação: Preparando o ambiente para PHP, Python ou Node.js.

  • Introdução ao Localhost e Servidores Remotos: VPS e Hospedagem.

  • Segurança Básica em Servidores: Firewalls de host e permissões de acesso.

Semana 5: Disponibilização de Aplicações e Projeto Prático

Objetivo: Colocar uma aplicação em rede e testar sua acessibilidade.

• Tópicos:

  • Configuração de Banco de Dados em Rede: Acessando o MySQL/PostgreSQL remotamente.

  • Publicação de Aplicação: Subindo o código para o servidor e configurando o domínio.

  • Testes de Conectividade e Latência: Garantindo que a aplicação está estável.

  • Projeto Final: Criação de um servidor local que hospeda uma página web ou sistema simples acessível por outros computadores da sala de aula.

Metodologia de Avaliação Sugerida

Atividade                                                Descrição                                                                                                                                                Peso

Atividade de Diagnóstico                      Identificação de falhas de rede e configuração de IPs em laboratório.                                                   20%

Laboratório de Servidor                         Instalação e configuração bem-sucedida de um servidor Web funcional.                                              30%

Projeto de Redes                                     Disponibilizar uma aplicação simples em rede local, permitindo o acesso de outros dispositivos.       50%

Planejamento de Ensino: Organização e Arquitetura de Computadores

Carga Horária Total: 40 Horas

Duração: 5 Semanas (8 horas por semana)

Ementa: Arquitetura geral de computadores: arquitetura de Von Neumann, organização dos principais componentes. Organização básica da UCP: estruturas internas, modo de operação, execução de instruções, pipeline, execução e interrupções. Formato das instruções e modos de endereçamento. Linguagem de máquina. Estruturas de memória: memória principal, secundária, cache e registradores, acessam a memória. Sistemas de entrada e saída. Barramentos.

Semana 1: Fundamentos e a Máquina de Von Neumann

Objetivo: Compreender a evolução das máquinas computacionais e a arquitetura clássica que baseia os computadores modernos.

• Tópicos (Encontros 1 e 2):

  • Introdução: Diferença entre Arquitetura de Computadores (o que a máquina faz) e Organização de Computadores (como ela é construída).

  • Arquitetura de Von Neumann: O conceito de programa armazenado.

  • Visão Geral dos Componentes: O modelo básico (CPU, Memória Principal e Sistema de Entrada/Saída).

  • Gargalo de Von Neumann: Entendendo a limitação de velocidade entre CPU e Memória.

  • Laboratório / Prática: Desmontagem e identificação física dos componentes em gabinetes abertos (placa-mãe, processador, slots de memória).

Semana 2: O Cérebro da Máquina (Organização da UCP/CPU)

Objetivo: Aprofundar o conhecimento no funcionamento interno do processador e como ele realiza o processamento de dados.

• Tópicos (Encontros 3 e 4):

  • Estrutura Interna da UCP: Unidade de Lógica e Aritmética (ULA/ALU) e Unidade de Controle (UC).

  • O Ciclo de Instrução: Busca (Fetch), Decodificação (Decode) e Execução (Execute).

  • Modos de Operação e Relógio (Clock): Frequência e sincronização de tarefas.

  • Pipeline: O conceito de linha de montagem para acelerar a execução de instruções.

  • Interrupções: Como o hardware pausa a CPU para tratar eventos urgentes.

Semana 3: A Ponte entre Software e Hardware

Objetivo: Entender como a linguagem humana (código de alto nível) é traduzida e executada no nível mais baixo do hardware.

• Tópicos (Encontros 5 e 6):

  • Linguagem de Máquina e Assembly: A diferença entre código binário e mnemônicos (ADD, MOV, JMP).

  • Formato das Instruções: Código de operação (Opcode) e Operandos.

  • Modos de Endereçamento: Imediato, direto, indireto e por registrador (como a CPU encontra os dados na memória).

  • Simulação Prática: Uso de um simulador didático (como o Little Man Computer ou simulador Assembly simples) para escrever e rodar um pequeno programa vendo os registradores mudarem.

Semana 4: Hierarquia de Memória

Objetivo: Compreender onde os dados são armazenados, a diferença de velocidade entre as memórias e como a CPU as acessa.

• Tópicos (Encontros 7 e 8):

  • O Conceito de Hierarquia: Custo, capacidade e velocidade (a pirâmide da memória).

  • Registradores: A memória interna e ultra-rápida da CPU (PC, IR, MAR, MBR).

  • Memória Cache: Níveis (L1, L2, L3) e o princípio da localidade (espacial e temporal).

  • Memória Principal (RAM/ROM): Armazenamento de trabalho e execução de programas.

  • Memória Secundária: HDDs, SSDs e armazenamento em massa.

Semana 5: Comunicação Externa (Barramentos e I/O)

Objetivo: Estudar como as diferentes partes do computador conversam entre si e com o mundo exterior.

• Tópicos (Encontros 9 e 10):

  • Sistemas de Barramentos (Buses): Barramento de Dados, Barramento de Endereços e Barramento de Controle.

  • Sistemas de Entrada e Saída (I/O): Técnicas de I/O programado, I/O guiado por interrupção e Acesso Direto à Memória (DMA).

  • Revisão da Arquitetura Completa: Como tudo se conecta ao executar um programa real.

  • Avaliação Prática / Projeto: Estudo de caso comparando as especificações de processadores e arquiteturas atuais (ex: x86/x64 vs. ARM/RISC) para justificar a escolha de hardware para um servidor de sistemas.

Metodologia de Avaliação Sugerida

Atividade

Descrição

Peso

Quiz de Componentes

Testes teóricos rápidos sobre memória, barramentos e ciclo de instrução.

20%

Laboratório de Simulador

Criação e execução de um pequeno programa em simulador Assembly/LMC, documentando o estado da CPU.

30%

Estudo de Caso Integrado

Avaliação final baseada na análise e especificação de uma arquitetura de hardware para rodar um sistema específico (ex: um servidor web de alta demanda).

50%

Planejamento de Ensino: Matemática Aplicada (para TI)

Carga Horária Total: 40 Horas

Duração: 5 Semanas (8 horas por semana, 2 encontros de 4h)

Ementa: Lógica matemática, teoria dos conjuntos, sistemas de numeração, funções, matrizes, noções de estatística descritiva e matemática financeira aplicadas ao desenvolvimento de software.

Semana 1: Lógica Matemática e Teoria dos Conjuntos

Objetivo: Desenvolver o raciocínio lógico rigoroso que é a base para criar algoritmos (condicionais IF/ELSE) e estruturar consultas em banco de dados.

• Tópicos:

  • Proposições e Conectivos Lógicos: E (AND), OU (OR), NÃO (NOT).

  • Tabela Verdade: Como o computador avalia múltiplas condições simultâneas.

  • Teoria dos Conjuntos: União, Interseção e Diferença.

  • Aplicação Prática em TI: Paralelo direto entre Teoria dos Conjuntos e comandos de Banco de Dados (INNER JOIN como interseção, estruturas condicionais em programação).

  • Prática: Resolução de problemas lógicos e montagem de tabelas verdade para simular regras de negócio (ex: "O usuário só pode fazer login SE a senha estiver correta E a conta estiver ativa").

Semana 2: Sistemas de Numeração e Álgebra Booleana

Objetivo: Compreender como a máquina processa e armazena a informação em baixo nível (bits e bytes).

• Tópicos:

  • Sistemas de Numeração: Decimal, Binário e Hexadecimal.

  • Conversão de Bases: Como converter de Decimal para Binário e Hexadecimal, e vice-versa.

  • Matemática Binária Básica: Operações fundamentais.

  • Aplicação Prática em TI: Entender como endereços IP (redes) são calculados, como as cores são formadas no CSS (código Hexadecimal, ex: #FFFFFF) e noções de conversão de tamanho de arquivos (Bytes, KB, MB, GB).

  • Prática: Exercícios de conversão de bases numéricas focados em cenários reais (ex: calcular a representação binária de uma máscara de sub-rede).

Semana 3: Funções, Vetores e Matrizes

Objetivo: Entender a matemática por trás da manipulação de listas, armazenamento temporário de dados e posicionamento de elementos em tela.

• Tópicos:

  • Plano Cartesiano e Funções (1º e 2º Grau): Eixos X e Y.

  • Vetores (Arrays Unidimensionais): Entendendo índices matemáticos (começando do zero).

  • Matrizes (Arrays Multidimensionais): Estruturação de dados em linhas e colunas.

  • Aplicação Prática em TI: Uso do plano cartesiano para desenhar interfaces web ou jogos (movimentação de elementos) e uso de matrizes para ler dados que vêm do banco e montar tabelas em HTML ou aplicativos.

  • Prática: Criar o modelo matemático/matriz para estruturar um tabuleiro da velha ou um mapa de assentos de cinema.

Semana 4: Estatística Básica para Dados

Objetivo: Capacitar o aluno a extrair e calcular métricas para geração de relatórios e construção de painéis administrativos (Dashboards).

• Tópicos:

  • Medidas de Tendência Central: Média (Simples e Ponderada), Moda e Mediana.

  • Leitura e Interpretação de Gráficos: Barras, pizza, dispersão.

  • Noções Básicas de Porcentagem e Proporção: Cálculos fundamentais.

  • Aplicação Prática em TI: Como calcular e exibir a média de notas de alunos em um sistema escolar, ou o produto mais vendido (Moda) em um sistema de e-commerce.

  • Prática: A partir de uma lista fictícia de vendas (simulando um JSON ou resposta de banco de dados), calcular os indicadores matemáticos que alimentarão um Dashboard de vendas.

Semana 5: Matemática Financeira Aplicada a Software

Objetivo: Aprender a calcular juros, taxas e descontos, fundamentais para quem vai desenvolver sistemas de vendas, assinaturas (SaaS) ou orçamentos.

• Tópicos:

  • Cálculo de Porcentagem Aplicada: Descontos e Acréscimos.

  • Juros Simples e Compostos: Fórmulas e aplicação no tempo.

  • Regra de Três Simples e Composta: Resolução rápida de proporções.

  • Aplicação Prática em TI: Programar a lógica de um carrinho de compras que aplica cupons de desconto, calcula frete baseado em proporção ou gera parcelamento com juros no cartão de crédito.

  • Prática (Projeto Final): Elaboração do memorial de cálculo (matemática no papel) para o fechamento de um orçamento de prestação de serviços (ex: cálculo de peças + margem de lucro + taxa do cartão), preparando a lógica que depois virará código.

Metodologia de Avaliação Sugerida

Atividade                                                                       Descrição                                                                                                                      Peso

Lista de Desafios Lógicos (Semana 1 e 2)                Resolução de problemas de tabela verdade e conversão                                                                                                                                                               binária/hexadecimal em sala de aula.                                                                             25%

Laboratório de Matrizes e Estatística                         Exercício avaliativo estruturando dados de uma tabela                                                                                                                                                                  fictícia e extraindo médias e porcentagens.                                                                   25%

Memorial de Cálculo de Sistema (Projeto Final)       O aluno receberá a descrição de um sistema comercial                                                                                                                                                                 (ex: sistema de assinaturas ou orçamentos) e deverá entregar                                                                                                                                                      no papel toda a matemática necessária para que a cobrança,                                                                                                                                                      juros e descontos funcionem corretamente.                                                                   50%

Planejamento de Ensino: Banco de Dados

Carga Horária Total: 40 Horas

Duração: 5 Semanas (8 horas por semana)

Ementa: Criação de modelos lógicos e físicos de banco de dados, manipulação dos dados através da linguagem SQL e configuração de Sistemas Gerenciadores de Banco de Dados (SGBD).

Semana 1: Fundamentos e Modelagem Lógica

Objetivo: Compreender o que é um banco de dados relacional e desenhar a estrutura da informação antes de ir para o computador.

• Tópicos:

  • Introdução a Banco de Dados: O que são dados, informação, Banco de Dados (BD) e Sistemas Gerenciadores de Banco de Dados (SGBD).

  • O Modelo Relacional: Conceito de Tabelas (Entidades), Colunas (Atributos) e Linhas (Registros/Tuplas).

  • Modelagem Entidade-Relacionamento (MER/DER): Como mapear o mundo real para o papel.

  • Relacionamentos e Cardinalidade: Ligações de 1:1, 1:N (Um para Muitos) e N:M (Muitos para Muitos).

  • Prática: Criação de diagramas lógicos baseados em cenários reais (ex: sistema de biblioteca ou loja).

Semana 2: Modelagem Física e Configuração do SGBD

Objetivo: Traduzir o modelo lógico para as regras do SGBD, aplicar normalização e preparar o ambiente de trabalho.

• Tópicos:

  • Chaves de Identificação: Chave Primária (PK) e Chave Estrangeira (FK).

  • Normalização de Dados: 1ª, 2ª e 3ª Formas Normais (como evitar redundância e anomalias).

  • Tipos de Dados: Inteiros, Decimais, Textos (VARCHAR) e Datas (DATE/DATETIME).

  • Configuração de SGBD: Instalação e configuração de um SGBD (ex: MySQL/MariaDB ou PostgreSQL) e uso de ferramentas visuais (ex: MySQL Workbench, DBeaver ou phpMyAdmin).

  • Prática: Conversão do diagrama lógico da semana anterior em um Modelo Físico compatível com o SGBD escolhido.

Semana 3: Linguagem SQL - Estrutura e Manipulação Básica

Objetivo: Começar a codificar o banco de dados, criando as tabelas e manipulando os primeiros registros.

• Tópicos:

  • Introdução ao SQL: O padrão universal de comunicação com bancos relacionais.

  • DDL (Data Definition Language): Comandos CREATE (criar tabelas e bancos), ALTER (modificar estruturas) e DROP (excluir).

  • DML (Data Manipulation Language) - Inserção: Comando INSERT INTO para popular as tabelas.

  • DML - Atualização e Exclusão Segura: Uso do UPDATE e DELETE (A regra de ouro: Nunca faça UPDATE/DELETE sem WHERE).

  • Laboratório: Script de criação das tabelas do projeto e inserção de dados fictícios.

Semana 4: Linguagem SQL - Consultas (Queries) e Junções

Objetivo: Extrair informações específicas e cruzar dados de diferentes tabelas para gerar relatórios úteis.

• Tópicos:

  • Consultas Básicas (DQL): O comando SELECT, uso da cláusula WHERE e operadores lógicos/relacionais (AND, OR, LIKE, IN).

  • Ordenação e Agrupamento: ORDER BY, GROUP BY e a restrição HAVING.

  • Funções de Agregação: Contagens, somas e médias (COUNT, SUM, AVG, MAX, MIN).

  • Junções de Tabelas (JOINs): Cruzando dados com INNER JOIN, LEFT JOIN e RIGHT JOIN.

  • Laboratório: Geração de "relatórios" via SQL (ex: listar todos os clientes que compraram um produto específico no último mês).

Semana 5: Segurança, Transações e Projeto Integrador

Objetivo: Administrar o banco de dados, criar rotinas de segurança e aplicar todo o conhecimento em um banco funcional.

• Tópicos:

  • Controle de Acesso (DCL): Criação de usuários e distribuição de permissões (GRANT e REVOKE).

  • Controle de Transações (TCL): Protegendo operações críticas com COMMIT e ROLLBACK.

  • Backup e Restauração: Como exportar (Dump) e importar um banco de dados completo.

  • Projeto Final Integrador: Modelagem, implementação, inserção de dados e criação de um conjunto de consultas complexas para um cenário de software proposto pelo professor (ex: Sistema de Matrículas Escolares).

Metodologia de Avaliação Sugerida

Atividade                                                        Descrição                                                                                             Peso

Quiz e Modelagem Lógica                             Exercício de desenho de Diagramas de Entidade-                                                                          Relacionamento e aplicação de chaves e normalização.                     20%            

Laboratório Prático de SQL                          Criação de um banco via scripts DDL e manipulação                                                                                                                                                                       básica de dados (DML) em tempo real.                                               30%                                    

Projeto Final de Banco de Dados                 Entrega do modelo físico completo de um sistema, script                                                                                                                                                              de geração, script de população (dados) e                                                                                                                                                                                      execução de 5 JOINs complexos com sucesso.                                  50%                              

Planejamento de Ensino: Arquitetura de Software

Carga Horária Total: 40 Horas

Duração: 5 Semanas (8 horas por semana)

Ementa Sugerida: Introdução a padrões de arquitetura de software, arquiteturas monolíticas vs. distribuídas, padrão MVC, desenvolvimento orientado a serviços, APIs RESTful, noções de arquitetura em nuvem e Serverless, e documentação de arquitetura.

Semana 1: Fundamentos e o Padrão MVC

Objetivo: Diferenciar código de arquitetura e dominar o padrão clássico mais utilizado na web.

• Tópicos:

  • O que é Arquitetura de Software: Diferença entre Design Patterns (nível de código) e Arquitetura (nível de sistema).

  • Arquiteturas em Camadas (Layered Architecture): Separação de responsabilidades (Apresentação, Regócio, Persistência).

  • O Padrão MVC (Model-View-Controller): Como ele funciona na prática.

  • Monólitos: Vantagens e desvantagens de ter toda a aplicação em um único bloco.

  • Prática: Analisar a estrutura de pastas e o fluxo de dados em um framework MVC tradicional (ferramentas baseadas em PHP, como CakePHP, são excelentes exemplos para ilustrar essa separação visualmente).

Semana 2: Arquitetura Cliente-Servidor e APIs RESTful

Objetivo: Compreender o desacoplamento de sistemas e a comunicação moderna na web.

• Tópicos:

  • Evolução do Cliente-Servidor: Quando o frontend se separa do backend.

  • Arquitetura REST e RESTful: Princípios, recursos e statelessness.

  • Verbos HTTP e Status Codes: A gramática da comunicação entre sistemas (GET, POST, PUT, DELETE).

  • Formatos de Troca de Dados: JSON e XML.

  • Prática: Desenhar os endpoints de uma API para um sistema escolar (ex: rotas para turmas, alunos e notas) e simular chamadas usando ferramentas como Postman ou Insomnia.

Semana 3: Microsserviços e Arquiteturas em Nuvem

Objetivo: Introduzir conceitos de sistemas distribuídos e o uso de infraestrutura como serviço.

• Tópicos:

  • Transição para Microsserviços: Quando quebrar o monólito? Desafios de comunicação e dados distribuídos.

  • Computação em Nuvem e Serverless: Reduzindo a dependência de servidores físicos.

  • BaaS (Backend as a Service): Acelerando o desenvolvimento com infraestrutura gerenciada.

  • Prática: Estudo de caso integrando uma aplicação frontend (como React) consumindo serviços em nuvem (como a arquitetura do Firebase para autenticação e banco de dados em tempo real).

Semana 4: Atributos de Qualidade, Segurança e Escalabilidade

Objetivo: Garantir que a arquitetura escolhida suporte o crescimento e seja segura.

• Tópicos:

  • Atributos de Qualidade (NFRs - Requisitos Não Funcionais): Desempenho, escalabilidade, disponibilidade e manutenibilidade.

  • Segurança na Arquitetura: Padrões de autenticação em sistemas distribuídos (Tokens JWT e OAuth).

  • Estratégias de Escalabilidade: Escalonamento Vertical (mais hardware) vs. Horizontal (mais instâncias).

  • Prática: Exercício de "Troubleshooting Arquitetural", onde os alunos recebem o desenho de uma arquitetura com falhas de gargalo de performance e precisam propor soluções.

Semana 5: Documentação de Arquitetura e Projeto Integrador

Objetivo: Aprender a comunicar decisões arquiteturais para outras equipes e consolidar o conhecimento.

• Tópicos:

  • Diagramas Arquiteturais: Introdução simplificada ao Modelo C4 (Contexto e Contêineres) ou UML (Componentes e Implantação).

  • ADRs (Architecture Decision Records): Como e por que documentar as escolhas de tecnologia.

  • Apresentação de Projetos: Defesa das escolhas arquiteturais.

  • Prática/Projeto Final: Os alunos devem desenhar a arquitetura completa de um sistema (como uma plataforma EAD corporativa ou um sistema de gestão educacional), justificando as escolhas de frameworks, padrões, banco de dados e modelo de implantação.

Metodologia de Avaliação Sugerida

Atividade                                               Descrição                                                                                                                                 Peso

Estudo de Caso (MVC x API)               Análise comparativa escrita identificando qual arquitetura 

                                                                é melhor para dois cenários distintos propostos.                                                                     20%

Desenho de API (REST)                       Entrega da documentação de endpoints (rotas, verbos, payloads)

                                                                para um módulo de sistema.                                                                                                     30%

Projeto Final (Design de Arquitetura)  Criação e defesa de um diagrama de arquitetura (Modelo C4 ou UML) 

                                                                 para resolver um problema de negócio real, acompanhado de um ADR.                                50%

Planejamento de Ensino: Programação Orientada a Objetos (com PHP)

Carga Horária Total: 40 Horas

Duração: 5 Semanas (8 horas por semana, 2 encontros de 4h)

Ementa: Introdução à orientação a objetos. Linguagens típicas orientadas a objetos. Programação Orientada a Objeto em PHP. Conceitos básicos e terminologias de Programação orientada a objetos. Classe, Objetos, Atributos, Métodos, Construtores e sobrecarga. Instanciação e Referência de objetos. Envio de mensagens. Ciclo de vida de um objeto. Abstração e encapsulamento. Herança. Criação e uso de hierarquia de classes. Classes abstratas e Interfaces. Relacionamento entre classes. Polimorfismo. Ligação dinâmica (dynamic binding). Tratamento de exceções.

Semana 1: O Mundo em Objetos e a Base do PHP Orientado a Objetos

Objetivo: Compreender a mudança de paradigma do PHP estruturado para o PHP orientado a objetos, criando as primeiras entidades.

• Tópicos:

  • Introdução à POO: O que é o paradigma de objetos e linguagens típicas. Como o PHP evoluiu para abraçar a POO de forma robusta.

  • Conceitos e Terminologias: Diferença entre Classe (o molde) e Objeto (a instância).

  • Estrutura Básica em PHP: Palavra reservada class. Atributos (propriedades) e Métodos (funções dentro da classe).

  • Na Prática: Instanciação (uso do new), o operador de objeto -> (em vez do ponto . usado em outras linguagens), e o uso da pseudo-variável $this para referenciar o próprio objeto.

  • Laboratório: Criar uma classe Produto em PHP com atributos como nome e preco e métodos como exibirDetalhes(). Instanciar objetos e acessar seus dados na tela do navegador.

Semana 2: Construção, Ciclo de Vida e Proteção de Dados (Encapsulamento)

Objetivo: Aprender a criar objetos de forma segura, garantindo que eles nasçam com dados válidos e que informações sensíveis não sejam expostas ou alteradas indevidamente.

• Tópicos:

  • Ciclo de Vida do Objeto: O nascimento e a destruição na memória.

  • Métodos Mágicos de Construção: O construtor __construct() e o destrutor __destruct().

  • O Desafio da Sobrecarga (Overloading) no PHP: Explicar que o PHP não suporta sobrecarga de métodos tradicional (mesmo nome, parâmetros diferentes) como o Java. Mostrar como o PHP resolve isso com parâmetros opcionais ou com o método mágico __call().

  • Abstração e Encapsulamento: Modificadores de visibilidade (public, private, protected).

  • Getters e Setters: Criando métodos para acessar e modificar propriedades privadas de forma segura.

  • Laboratório: Refatorar a classe Produto. Tornar o preco privado e criar um método setPreco($valor) que impeça o preço de ser um número negativo.

Semana 3: Reutilização de Código (Herança e Relacionamentos)

Objetivo: Evitar a duplicação de código criando famílias de classes e fazendo os objetos interagirem entre si.

• Tópicos:

  • Herança (O conceito "É um"): Uso da palavra-chave extends. Relação entre Classe Pai (Superclasse) e Classe Filha (Subclasse). Acessando a classe pai com parent::.

  • Hierarquia de Classes: Criando árvores de especialização (ex: Funcionario -> Gerente e Vendedor).

  • Relacionamento entre Classes (O conceito "Tem um"): Associação, Agregação e Composição em PHP (ex: Injetar um objeto Categoria dentro da classe Produto).

  • Laboratório: Criar um pequeno sistema de e-commerce onde as classes ProdutoFisico (com frete) e ProdutoDigital (com link de download) herdam da superclasse Produto. Relacionar o Produto a uma classe Fornecedor.

Semana 4: Contratos e Comportamentos Dinâmicos

Objetivo: Dominar ferramentas avançadas para criar sistemas padronizados, flexíveis e escaláveis.

• Tópicos:

  • Classes Abstratas: Classes que não podem ser instanciadas diretamente (abstract class) e métodos abstratos.

  • Interfaces: Criando contratos de comportamento obrigatório (interface e implements).

  • Polimorfismo: "Muitas formas" - Objetos de classes diferentes respondendo ao mesmo método de formas diferentes (sobrescrevendo métodos da classe pai).

  • Ligação Dinâmica (Dynamic Binding) e Type Hinting: Como o PHP descobre em tempo de execução qual método rodar e como forçar tipos em parâmetros de métodos (ex: public function salvar(LogInterface $log)).

  • Laboratório: Criar um sistema de Notificações com uma interface Notificacao. Classes como EmailNotificacao e SMSNotificacao devem implementar o método enviar() de maneiras diferentes.

Semana 5: Tratamento de Exceções e Projeto Integrador

Objetivo: Aprender a lidar com imprevistos para que a aplicação PHP não exiba os famosos "Fatal Errors" na tela do usuário.

• Tópicos:

  • Tratamento de Exceções: Como capturar erros graciosamente.

  • Blocos de Proteção: Uso de try, catch e finally. A classe base Exception.

  • Lançamento de Exceções: Como usar o throw new Exception() para sinalizar problemas (ex: "E-mail inválido").

  • Projeto Final Integrador: Modelagem e implementação de um mini-sistema CRUD em PHP utilizando a classe nativa do PHP PDO (PHP Data Objects), que por si só já é um excelente exemplo de POO.

  • Laboratório: Criar um sistema de Cadastro de Clientes onde o aluno utilize: Encapsulamento, Relacionamento de Classes (ex: um Cliente tem um Endereço), tratamento de exceções (ex: tentar cadastrar um CPF que já existe no BD e capturar o erro com try/catch) e conexão com o banco de dados via PDO.

Metodologia de Avaliação Sugerida

Atividade

Descrição

Peso

Quiz Teórico/Prático e Encapsulamento (Semanas 1 e 2)

Criação de classes e objetos em PHP, uso correto de __construct, $this e aplicação de encapsulamento com private e métodos validadores.

20%

Laboratório de Arquitetura em PHP (Semanas 3 e 4)

Avaliação prática em que os alunos implementam uma hierarquia com extends e criam interfaces para garantir contratos (Polimorfismo).

30%

Projeto Final (Semana 5)

Entrega do sistema (ex: Carrinho de Compras ou Sistema de Gestão) em PHP Orientado a Objetos, com tratamento de exceções rodando sem exibir "Warnings" ou "Fatal Errors" nativos.

50%

Planejamento de Ensino: Desenvolvimento de Aplicações para Internet (Foco em PHP)

Carga Horária Total: 40 Horas

Duração: 5 Semanas (8 horas por semana, 2 encontros de 4h)

Ementa Adaptada: Conceitos básicos do ambiente web, suas linguagens e protocolos. Introdução à linguagem PHP, seus componentes e APIs. Tratamento de requisições e renderização de páginas (Equivalência a Servlet e JSP). Modelo MVC.

Semana 1: O Ambiente Web e a Base do PHP

Objetivo: Entender como a internet funciona nos bastidores e preparar o servidor local para rodar os primeiros scripts PHP.

• Tópicos:

  • Conceitos do Ambiente Web: Arquitetura Cliente-Servidor (Navegador vs. Servidor).

  • O Protocolo HTTP: O fluxo de Requisição (Request) e Resposta (Response), verbos GET e POST.

  • Introdução ao PHP: O que é uma linguagem Server-side (interpretada no servidor).

  • Configuração de Ambiente: Instalação do XAMPP (Apache + PHP + MySQL) e configuração do diretório htdocs.

  • Sintaxe Básica: Tags <?php ?>, variáveis ($var), arrays clássicos do PHP e funções básicas.

  • Laboratório: Criar o primeiro script dinâmico, acessá-lo via localhost e entender como o Apache processa o PHP e devolve apenas HTML para o navegador.

Semana 2: Tratamento de Requisições (O conceito de "Servlet" no PHP)

Objetivo: Fazer o sistema receber dados digitados pelo usuário, processar regras lógicas no servidor e devolver um resultado.

• Tópicos:

  • Variáveis Superglobais: Entendendo profundamente o $_GET (dados na URL) e o $_POST (dados ocultos no corpo da requisição).

  • Processamento de Formulários: Como um arquivo PHP atua como um "Controlador" (equivalente ao Servlet), recebendo os dados do formulário HTML.

  • Validação e Sanitização: Regras de segurança básicas antes de processar dados do usuário.

  • Redirecionamento: Uso da função header("Location: ...").

  • Laboratório: Criar um formulário HTML de cadastro ou cálculo matemático que envia dados via POST para um arquivo PHP focado exclusivamente em processar a matemática/lógica do sistema.

Semana 3: Camada de Visão e Templates (O conceito de "JSP" no PHP)

Objetivo: Parar de misturar regras complexas de negócio junto com o design visual da página.

• Tópicos:

  • A Natureza de Template do PHP: Como o PHP nasceu para ser embutido no HTML (o exato mesmo conceito do JSP).

  • Separação de Responsabilidades (O início do MVC): O problema do "Código Espaguete" (misturar consultas de banco, regras lógicas e tags <div> no mesmo arquivo).

  • Uso de Includes/Requires: Como modularizar o layout (header.php, footer.php) usando include_once e require_once.

  • Laboratório: Refatorar o exercício da semana 2. Agora, o formulário envia para um arquivo PHP (Controlador) que faz a lógica, e este arquivo inclui um segundo arquivo PHP (Visão) que contém apenas o HTML exibindo o resultado usando <?= $variavel ?>.

Semana 4: O Modelo MVC e Gerenciamento de Sessão

Objetivo: Estruturar a aplicação seguindo o padrão de mercado MVC e criar sistemas de login para identificar os usuários.

• Tópicos:

  • O Modelo MVC (Model-View-Controller) em PHP:

    • Model (Modelo): Classes PHP que lidam com os dados e regras de negócio.

    • View (Visão): Arquivos PHP focados na interface (HTML/CSS).

    • Controller (Controlador): Arquivos PHP que recebem a requisição, chamam o Model e entregam a View.

  • O "Estado" da Web: O protocolo HTTP não tem memória.

  • Gerenciamento de Sessões: Uso de session_start() e da superglobal $_SESSION para manter o usuário logado.

  • Laboratório: Criar um sistema de Autenticação MVC. Uma tela de login (View) envia para o Controller que valida a senha (no Model). Se correto, salva na $_SESSION e libera o acesso a um "Painel Administrativo".

Semana 5: APIs, Integração com Banco de Dados e Projeto Final

Objetivo: Conectar o padrão MVC a um banco de dados real e criar um sistema completo.

• Tópicos:

  • Conexão com Banco de Dados: Uso da API PDO (PHP Data Objects) para comunicação segura com bancos como MySQL/MariaDB.

  • Prevenção de SQL Injection: Uso de Prepared Statements na PDO.

  • Padrão DAO (Data Access Object): Isolando as queries (SELECT, INSERT) dentro do Model.

  • Introdução a APIs em PHP: Como fazer um arquivo PHP devolver dados em JSON (json_encode) em vez de HTML, permitindo integrações.

  • Projeto Final Integrador: Desenvolvimento de um sistema web CRUD completo estruturado em MVC (ex: Sistema de Gerenciamento de Alunos ou Produtos), com banco de dados MySQL rodando no XAMPP.

Metodologia de Avaliação Sugerida

Atividade

Descrição

Peso

Laboratório de Processamento (Semanas 1 e 2)

Criação de um formulário que capta dados via POST e aplica regras de validação no back-end PHP.

20%

Implementação MVC e Sessão (Semanas 3 e 4)

Entrega do "Sistema de Login", avaliando se o aluno conseguiu separar os arquivos de Controller e View corretamente, além de proteger rotas com $_SESSION.

30%

Projeto Final (CRUD MVC com PDO) (Semana 5)

Entrega do mini-sistema aplicando todo o fluxo: Formulário web cadastrando, listando e excluindo dados reais integrados ao banco MySQL, seguindo a arquitetura MVC.

50%

Planejamento de Ensino: Educação Inclusiva e Tecnologias Assistivas

Carga Horária Total: 40 Horas

Duração: 5 Semanas (8 horas por semana, 2 encontros de 4h)

Ementa: A educação especial: aspectos históricos e sua inserção no contexto do Sistema Educacional Brasileiro. As políticas públicas de inclusão, abordagens e tendências.

Semana 1: Aspectos Históricos da Educação Especial

Objetivo: Compreender a evolução do tratamento dado às pessoas com deficiência ao longo da história e os diferentes paradigmas até chegarmos à inclusão.

• Tópicos:

  • Os 4 Paradigmas Históricos: Exclusão (fase de extermínio/abandono), Segregação (institucionalização em asilos/hospitais), Integração (a pessoa deve se adaptar ao meio) e Inclusão (o meio deve ser adaptado para receber a pessoa).

  • Movimentos Sociais e Direitos Humanos: O impacto das guerras mundiais e as Declarações Internacionais (Declaração de Salamanca, 1994).

  • O Modelo Social da Deficiência: A deficiência não está apenas no indivíduo, mas na barreira imposta pelo ambiente físico ou digital.

  • Prática: Dinâmica de sensibilização. Simulação de navegação na web usando apenas o teclado (sem o mouse) e de olhos vendados usando um leitor de tela (como o NVDA ou o Narrador do Windows), para sentirem na pele as barreiras tecnológicas.

Semana 2: A Inclusão no Sistema Educacional Brasileiro

Objetivo: Analisar como o Brasil estruturou suas leis para garantir o acesso e a permanência de pessoas com deficiência nas escolas e no mercado de trabalho.

• Tópicos:

  • Constituição Federal (1988) e LDB (Lei de Diretrizes e Bases da Educação): O direito à educação "preferencialmente na rede regular de ensino".

  • Atendimento Educacional Especializado (AEE): O que é, salas de recursos multifuncionais e o papel do educador.

  • Público-Alvo da Educação Especial: Deficiência (Física, Intelectual, Visual, Auditiva), Transtorno do Espectro Autista (TEA) e Altas Habilidades/Superdotação.

  • Prática: Estudo de caso. Os alunos analisarão o site de uma instituição de ensino brasileira para identificar se ele cumpre os requisitos mínimos de acessibilidade para atender o público-alvo da educação especial.

Semana 3: Políticas Públicas de Inclusão

Objetivo: Aprofundar o conhecimento nas legislações mais recentes que impactam diretamente a criação de produtos, serviços e softwares no Brasil.

• Tópicos:

  • Política Nacional de Educação Especial na Perspectiva da Educação Inclusiva (2008).

  • Estatuto da Pessoa com Deficiência (Lei Brasileira de Inclusão - LBI, 2015): Foco especial no artigo que exige acessibilidade em sites e sistemas mantidos por empresas no Brasil (Art. 63).

  • Lei de Cotas: A inclusão no mercado de trabalho.

  • Prática: Debate guiado e pesquisa. Como a LBI pode gerar processos judiciais contra empresas que desenvolvem softwares inacessíveis?

Semana 4: Abordagens, Tendências e Tecnologias Assistivas

Objetivo: Conectar a legislação à tecnologia, mostrando como o Desenvolvedor de Sistemas atua como agente de inclusão social.

• Tópicos:

  • O que é Tecnologia Assistiva (TA): Recursos, metodologias e serviços que ampliam a autonomia da pessoa com deficiência.

  • TAs no Hardware: Teclados colmeia, mouses adaptados, acionadores por piscar de olhos, impressoras Braille.

  • TAs no Software: Leitores de tela (NVDA, JAWS, VoiceOver), ampliadores de tela, avatares de Libras (ex: Hand Talk).

  • Desenvolvimento Acessível e Tendências: Inteligência Artificial aplicada à inclusão (reconhecimento de imagem para cegos, legendagem automática) e introdução à WCAG (Diretrizes de Acessibilidade para Conteúdo Web).

  • Prática: Os alunos deverão baixar e testar a extensão "Lighthouse" no Google Chrome ou a ferramenta "WAVE" para auditar a acessibilidade de sistemas web famosos e identificar as falhas.

Semana 5: O Desenvolvedor Inclusivo (Projeto Integrador)

Objetivo: Aplicar os conceitos de inclusão, leis e tecnologias assistivas na elaboração de um projeto tecnológico.

• Tópicos:

  • Design Universal: Criar produtos que possam ser usados pelo maior número de pessoas possível, sem necessidade de adaptação.

  • Boas práticas de código inclusivo: Atributos alt em imagens, contraste de cores, semântica do HTML para leitores de tela.

  • Apresentação de Projetos: Defesa das soluções tecnológicas propostas.

  • Prática (Projeto Final): Elaboração de um protótipo visual (ou conceitual) de um aplicativo ou sistema web voltado para a educação. Os alunos devem justificar como o sistema atende à LBI, qual público ele inclui e quais Tecnologias Assistivas seriam compatíveis com ele.

Metodologia de Avaliação Sugerida

Atividade

Descrição

Peso

Relatório de Auditoria de Acessibilidade (Semanas 1 e 2)

Avaliação prática em que o aluno navega em um sistema escolar real, usando leitores de tela e teclado, relatando as barreiras de inclusão encontradas.

25%

Estudo de Legislação (Semana 3)

Questionário ou seminário curto sobre como a Lei Brasileira de Inclusão obriga o mercado de tecnologia a se adaptar.

25%

Projeto de Software Inclusivo (Semanas 4 e 5)

Entrega do planejamento de um software educacional (pode ser o desenho de telas) focado no Design Universal, justificando quais TAs ele suporta.

50%

Planejamento de Ensino: Desenvolvimento de Sistemas para Dispositivos Móveis

Carga Horária Total: 40 Horas

Duração: 5 Semanas (8 horas por semana, 2 encontros de 4h)

Ementa: Introdução a dispositivos móveis. Comunicação sem fio, plataforma de software e sistemas operacionais para dispositivos móveis. Ambiente de desenvolvimento para construção de aplicações móveis. Criação de aplicativos para dispositivos móveis. Envio de aplicativo móvel para loja de aplicativos.

Semana 1: O Ecossistema Mobile e Preparação do Ambiente

Objetivo: Entender a diferença entre desenvolver para web e para mobile, conhecer os sistemas operacionais e configurar as ferramentas de trabalho.

• Tópicos:

  • Introdução aos Dispositivos Móveis: A evolução dos celulares até os smartphones.

  • Sistemas Operacionais: A hegemonia do Android (Google) e iOS (Apple). Diferenças de arquitetura e mercado.

  • Comunicação Sem Fio e Redes: Como os apps consomem dados via Wi-Fi, 4G/5G, Bluetooth e NFC. O impacto da latência e perda de conexão no design do app.

  • Plataformas de Software (Nativo vs. Híbrido): Diferença entre programar em Java/Kotlin/Swift puro ou usar frameworks multiplataforma (React Native, Flutter).

  • Ambiente de Desenvolvimento: Instalação do Node.js, VS Code e configuração do ambiente (ex: CLI do Expo ou Flutter).

  • Laboratório: Criar o projeto "Hello World", conectar o celular do aluno ao computador via Wi-Fi (usando um app de testes como o Expo Go) e ver o código refletindo na tela do smartphone em tempo real.

Semana 2: Componentes Visuais e Criação de Telas

Objetivo: Aprender a desenhar interfaces responsivas que se adaptam a diferentes tamanhos de tela (do celular pequeno ao tablet).

• Tópicos:

  • Design Mobile (UI/UX): Regras de ouro para mobile (tamanho de botões para o toque do dedo, áreas de respiro, contraste).

  • Componentes Básicos: Textos, Botões, Imagens, Entradas de Texto (Inputs) e Listas de Rolagem (Scroll/FlatList).

  • Layout e Posicionamento: Como organizar elementos na tela usando conceitos de Flexbox (linhas, colunas, alinhamentos).

  • Gerenciamento de Estado: Como o aplicativo reage quando o usuário clica em algo e o dado muda na tela.

  • Laboratório: Construir a interface visual completa de um aplicativo simples (ex: Uma tela de Login e uma tela de Perfil ou Catálogo de Produtos), focando apenas no visual e na responsividade.

Semana 3: Navegação e Consumo de APIs (Conectando à Web)

Objetivo: Fazer o aplicativo ter múltiplas telas e buscar dados reais na internet, conectando com o que aprenderam nas disciplinas de Back-end (PHP/Java).

• Tópicos:

  • Roteamento e Navegação: Como transitar entre telas (Navegação em Pilha/Stack, Abas Inferiores/Tabs e Menu Lateral/Drawer).

  • Passagem de Parâmetros: Como enviar um dado de uma tela para outra (ex: Clicar em um produto na lista e abrir a tela de detalhes dele).

  • Consumo de APIs REST (Comunicação na prática): Como usar requisições assíncronas (Fetch/Axios) para buscar dados em formato JSON na nuvem.

  • Laboratório: Conectar o aplicativo criado na semana anterior a uma API pública (como ViaCEP para buscar endereços ou TheMovieDB para buscar filmes), popular as listas na tela e criar a navegação entre a lista e os detalhes.

Semana 4: Recursos do Aparelho e Integração com a Nuvem

Objetivo: Utilizar os recursos físicos do smartphone e conectar o app a um banco de dados em nuvem em tempo real.

• Tópicos:

  • Hardware e Sensores: Como solicitar permissões ao usuário e acessar a Câmera, Galeria de Fotos ou GPS/Localização.

  • Armazenamento Local: Como guardar pequenos dados no aparelho para uso offline (ex: Manter o usuário logado usando AsyncStorage ou SharedPreferences).

  • Integração com Backend as a Service (BaaS): Introdução rápida ao Firebase (Autenticação ou Banco de Dados em tempo real).

  • Laboratório: Adicionar a funcionalidade de "Tirar uma Foto" no app e configurar um sistema de Login usando uma plataforma em nuvem para validar o acesso.

Semana 5: O Processo de Publicação e Projeto Integrador

Objetivo: Fechar o ciclo de desenvolvimento, gerando o arquivo final do aplicativo e entendendo a burocracia para colocá-lo nas lojas.

• Tópicos:

  • Geração de Build: Como compilar o código e gerar os pacotes finais: APK/AAB (para Android) e IPA (para iOS).

  • Lojas de Aplicativos: Visão geral do Google Play Console e Apple App Store Connect.

  • Requisitos para Publicação: Certificados, assinaturas digitais (Keystore), ícones, prints de tela, políticas de privacidade e taxas de desenvolvedor.

  • Projeto Final Integrador: Conclusão e apresentação do aplicativo desenvolvido.

  • Laboratório: Os alunos devem gerar o arquivo .apk final de seus projetos, instalá-lo de forma nativa no aparelho (sem depender do cabo ou rede de desenvolvimento) e apresentar o app rodando para a turma.

Metodologia de Avaliação Sugerida

Atividade

Descrição

Peso

Criação de Interface (Semana 2)

Entrega do design de telas de um app, avaliando o uso correto de componentes visuais, layout (Flexbox) e usabilidade.

20%

Navegação e API (Semana 3)

Laboratório prático onde o aluno deve criar um app de múltiplas telas que busca e exibe dados de uma API externa via rede sem fio.

30%

Projeto Final e Build (Semanas 4 e 5)

Entrega do arquivo final (APK) de um aplicativo funcional. O app deve ter navegação, acesso a pelo menos um recurso nativo (como câmera, GPS ou armazenamento) e estar pronto para uso no celular.

50%

Planejamento de Ensino: Engenharia de Software

Carga Horária Total: 40 Horas

Duração: 5 Semanas (8 horas por semana, 2 encontros de 4h)

Ementa: Princípios da Engenharia de Software. A importância do software. Características do software e aplicações. A crise do software. Mitos do desenvolvimento de software. Processos de software. Requisitos de software. Modelagem de sistemas. Qualidade de software. Estudos de Casos.

Semana 1: Fundamentos, Histórico e os Mitos do Software

Objetivo: Mostrar por que a Engenharia de Software foi criada, os erros do passado e como quebrar os falsos paradigmas que programadores iniciantes têm.

• Tópicos:

  • A Importância e Características do Software: Software não "gasta" nem estraga com o tempo (não tem desgaste físico), mas sofre com manutenção e obsolescência. Diferença entre software de sistema e software de aplicação.

  • A Crise do Software (Anos 60/70): Por que os projetos começaram a estourar prazos, orçamentos e a falhar miseravelmente.

  • Princípios da Engenharia de Software: A transição da programação amadora para a engenharia profissional.

  • Mitos do Desenvolvimento: Quebrando falácias clássicas (ex: "Se o projeto está atrasado, basta colocar mais programadores" - Lei de Brooks; ou "O trabalho termina quando o código funciona").

  • Prática: Dinâmica de grupo. Dividir a turma e pedir que tentem construir uma torre de copos ou legos com regras mudando a todo instante, ilustrando o caos da falta de planejamento.

Semana 2: Modelos e Processos de Software

Objetivo: Entender os diferentes "caminhos" e metodologias que uma equipe pode adotar para construir um sistema do início ao fim.

• Tópicos:

  • O que é um Processo de Software: O ciclo de vida clássico (Comunicação, Planejamento, Modelagem, Construção e Implantação).

  • Modelos Tradicionais (Prescritivos): Modelo Cascata (Waterfall), Incremental e Espiral. Vantagens e desvantagens.

  • O Manifesto Ágil e as Metodologias Ágeis: Por que o mercado mudou. A flexibilidade sobre a documentação rígida.

  • Scrum e Kanban (Visão Geral): Papéis (Product Owner, Scrum Master, Dev Team), Cerimônias (Daily, Sprint Review) e quadros de tarefas.

  • Prática: Simular uma "Sprint Planning" na sala de aula. Os alunos recebem a ideia de um aplicativo e precisam criar e estimar as tarefas em um quadro Kanban (usando Trello ou post-its na parede).

Semana 3: Engenharia de Requisitos

Objetivo: Aprender a traduzir o que o cliente diz que quer para o que ele realmente precisa, criando o contrato de escopo do sistema.

• Tópicos:

  • O que são Requisitos: A ponte entre a área de negócios e a área técnica.

  • Requisitos Funcionais: O que o sistema deve fazer (ex: "O sistema deve emitir um relatório de vendas em PDF").

  • Requisitos Não Funcionais: Como o sistema deve ser (ex: "O sistema deve carregar a tela em menos de 2 segundos" - Segurança, Performance, Usabilidade).

  • Regras de Negócio: Restrições que não dependem do software, mas devem ser aplicadas nele.

  • Técnicas de Elicitação: Como extrair informações do cliente (Entrevistas, Observação, Prototipação).

  • Prática: Roleplay (Encenação). O professor atua como um "cliente confuso" de uma pizzaria que quer um aplicativo. Os alunos devem entrevistá-lo e redigir o Documento de Requisitos (Funcionais e Não Funcionais).

Semana 4: Modelagem de Sistemas e Qualidade de Software

Objetivo: Desenhar as plantas do sistema (como um arquiteto faz com uma casa) e garantir que o produto final seja testado e livre de falhas críticas.

• Tópicos:

  • Introdução à Modelagem: Por que desenhar antes de programar?

  • UML (Linguagem de Modelagem Unificada): Foco nos diagramas mais utilizados pelo mercado: Diagrama de Casos de Uso (Visão do usuário) e Diagrama de Classes (Visão de estrutura).

  • Qualidade de Software: O que define um "bom" software? (Manutenibilidade, Confiabilidade, Eficiência).

  • Testes de Software: Diferença entre Teste de Unidade, Teste de Integração e Teste de Aceitação pelo usuário.

  • Laboratório: Utilizar ferramentas como o Draw.io ou Lucidchart para desenhar o Diagrama de Casos de Uso do sistema de pizzaria levantado na semana anterior.

Semana 5: Estudos de Caso e Fechamento

Objetivo: Analisar sistemas reais, aprender com falhas catastróficas do passado e consolidar o aprendizado em um planejamento completo.

• Tópicos:

  • Estudos de Caso de Falhas Famosas: O caso do Therac-25 (máquina de radioterapia que matou pacientes por erro de software), o foguete Ariane 5 ou casos recentes de vazamentos de dados por má engenharia.

  • Estudos de Caso de Sucesso: Como grandes empresas organizam suas equipes e processos.

  • Projeto Integrador Final: Unindo requisitos, modelagem e processos.

  • Prática: Apresentação final. Os alunos recebem um Estudo de Caso de um problema de negócios local (ex: informatizar um posto de saúde do bairro). Eles não vão programar, mas devem entregar o "Dossiê de Engenharia" da solução.

Metodologia de Avaliação Sugerida

Atividade

Descrição

Peso

Estudo de Caso e Processos (Semanas 1 e 2)

Atividade em grupo onde analisam um cenário de desastre de software e propõem qual metodologia de processo (Cascata ou Ágil) poderia ter evitado o problema.

20%

Documento de Requisitos e UML (Semanas 3 e 4)

Entrega do levantamento completo de requisitos (Funcionais, Não Funcionais e Regras de Negócio) junto com o Diagrama de Casos de Uso de um sistema proposto.

30%

Dossiê Final de Engenharia (Semana 5)

Trabalho final em equipe simulando uma consultoria de software. Apresentação da proposta, cronograma, modelo de equipe, requisitos e modelagem para resolver um problema real, justificando as garantias de Qualidade.

50%

Planejamento de Ensino: Programação Web I (Foco em PHP Avançado)

Carga Horária Total: 40 Horas

Duração: 5 Semanas (8 horas por semana, 2 encontros de 4h)

Ementa: Linguagens de Programação para desenvolvimento de aplicações web. Websites dinâmicos baseados em novas tecnologias e com acesso a banco de dados. Métodos e técnicas de desenvolvimento de aplicações avançadas para web. Soluções na otimização e melhoria do desempenho de web sites. Funcionamento básico de um servidor de Internet.

Semana 1: A Espinha Dorsal da Web e Servidores

Objetivo: Desmistificar como a internet funciona nos bastidores e preparar o ambiente de hospedagem local.

• Tópicos:

  • O Servidor de Internet: Como funcionam servidores web (Apache, Nginx) e o fluxo de portas (HTTP na porta 80, HTTPS na 443).

  • Ambiente de Desenvolvimento: Configuração avançada do XAMPP, entendendo o arquivo php.ini (limites de upload, tempo de execução e exibição de erros).

  • Estático vs. Dinâmico: A diferença estrutural entre sites entregues prontos (HTML puro) e sites montados em tempo de execução pelo PHP.

  • Novas Tecnologias: O papel do PHP 8+ no ecossistema atual e como ele se comunica com o front-end moderno.

  • Prática: Criar um script PHP que analisa os cabeçalhos (headers) do navegador do usuário e exibe informações do servidor (phpinfo()).

Semana 2: Técnicas Avançadas de Programação Web

Objetivo: Sair do PHP básico e aplicar técnicas modernas de manipulação de dados e segurança.

• Tópicos:

  • Manipulação de Arquivos e Uploads: Como receber imagens ou PDFs via formulário de forma segura, renomear arquivos e movê-los para pastas do servidor.

  • Segurança na Web: Como proteger aplicações contra as falhas mais comuns (XSS - Cross-Site Scripting, CSRF e Injeção de Código).

  • Consumo e Criação de APIs (JSON): Como usar o PHP para ler dados externos (ex: buscar um CEP usando a função file_get_contents ou cURL) e como responder em formato JSON.

  • Prática: Criar um sistema seguro de upload de imagens de perfil, onde o PHP verifica a extensão do arquivo e o tamanho máximo antes de salvar no servidor.

Semana 3: Aplicações Dinâmicas e Banco de Dados

Objetivo: Conectar o sistema a um banco de dados relacional com foco em segurança e performance na extração das informações.

• Tópicos:

  • Modelagem e Conexão: Revisão da conexão com MySQL utilizando PDO (PHP Data Objects).

  • Prevenção de SQL Injection: Uso obrigatório de Prepared Statements (bind de parâmetros).

  • CRUD Avançado: Consultas complexas (JOINs) feitas diretamente pelo PHP para montar painéis administrativos (Dashboards).

  • Paginação de Resultados: Como usar as cláusulas LIMIT e OFFSET para não travar a tela quando o banco tem milhares de registros.

  • Prática: Desenvolver uma listagem de registros puxados do MySQL, implementando uma barra de busca funcional e paginação (exibindo 10 itens por página).

Semana 4: Otimização e Melhoria de Desempenho

Objetivo: Garantir que o site carregue rapidamente e consuma poucos recursos do servidor e da banda de internet do usuário.

• Tópicos:

  • Os Gargalos da Web: Por que os sites ficam lentos? (Imagens pesadas, excesso de requisições, queries de banco mal feitas).

  • Otimização de Front-end no PHP: Minificação de recursos e compressão GZIP.

  • Cache de Dados: Como evitar consultas repetidas ao banco de dados gerando arquivos estáticos temporários ou usando sessões inteligentemente.

  • Lazy Loading: Técnicas para carregar imagens e dados apenas quando o usuário rolar a tela.

  • Prática: Utilizar a ferramenta "Lighthouse" do Google Chrome para auditar o sistema criado na Semana 3, identificar os pontos de lentidão e aplicar as correções no código para atingir uma nota superior a 90 em Performance.

Semana 5: Projeto Integrador

Objetivo: Unir todos os conceitos em uma aplicação robusta, com banco de dados e foco na experiência do usuário.

• Tópicos:

  • Arquitetura de Projeto: Estruturação de pastas, padronização de código (PSR) e clareza.

  • Desenvolvimento e Refatoração: Tempo dedicado à codificação com mentoria do professor.

  • Prática (Projeto Final): Desenvolvimento de um sistema de gestão educacional (como um mini-portal para controle de turmas de qualificação profissional, onde instrutores registram alunos, fazem upload de materiais em PDF e extraem relatórios paginados em tela). O sistema deve demonstrar o uso de rotas seguras, proteção contra injeção e carregamento otimizado.

Metodologia de Avaliação Sugerida

Atividade

Descrição

Peso

Laboratório de Segurança e Uploads (Semanas 1 e 2)

Criação de um formulário que recebe arquivos, valida a segurança da extensão e salva corretamente no servidor.

20%

Listagem com Paginação (Semana 3)

Avaliação focada em extrair dados do MySQL de forma segura usando PDO e aplicar paginação via PHP.

30%

Sistema Integrado e Otimizado (Semanas 4 e 5)

Entrega do projeto final (ex: Portal de Gestão Educacional). Além de funcionar, o código passará pela auditoria do Lighthouse para comprovar as métricas de desempenho.

50%