Resumo do 1º bimestre 2026

A – Primeiro Bloco

1. O que é levantamento de requisitos

• É a etapa de coleta, análise, documentação e manutenção das necessidades do sistema.
• Serve para garantir que o software atenda às necessidades dos usuários e aos objetivos do negócio.
• É uma fase essencial para evitar erros, retrabalho, atrasos e custos extras.

Palavras-chave:
levantamento de requisitos, necessidades do usuário, objetivos do negócio, documentação, análise, ciclo de vida do projeto

---

2. Importância dos requisitos

• Funcionam como a base do projeto de software.
• Ajudam a alinhar cliente, equipe e stakeholders.
• Reduzem mal-entendidos e mudanças tardias.
• Melhoram a qualidade da entrega final.

Palavras-chave:
base do projeto, alinhamento, stakeholders, qualidade, comunicação, redução de riscos

---

3. Requisitos funcionais

• Descrevem o que o sistema deve fazer.
• Representam funções, ações e operações que o usuário pode executar.
• Exemplos:
  • criar conta e fazer login;
  • agendar consulta;
  • cancelar ou reagendar consulta;
  • enviar notificações automáticas.

Palavras-chave:
requisitos funcionais, funcionalidades, ações do sistema, operações, comportamento esperado

---

4. Requisitos não funcionais

• Descrevem como o sistema deve ser ou se comportar.
• Envolvem atributos de qualidade, como:
  • desempenho;
  • segurança;
  • confiabilidade;
  • usabilidade;
  • compatibilidade;
  • conformidade legal.

Palavras-chave:
requisitos não funcionais, desempenho, segurança, usabilidade, confiabilidade, conformidade, compatibilidade

---

5. Exemplos práticos apresentados

Aplicativo bancário

• Permitir transações, consulta de saldo e notificações.
• Definir tanto funcionalidades quanto comportamento esperado do sistema.

Aplicativo de agendamento de consultas

• Marcar, reagendar e cancelar consultas.
• Enviar lembretes e orientações preparatórias.
• Melhorar a gestão do tempo dos médicos.

Software de e-commerce

• Cadastro de usuários, carrinho de compras e checkout.
• Requisitos de escalabilidade, criptografia e conformidade.

Aplicativo de finanças pessoais

• Caso usado para mostrar mudanças de requisitos durante o projeto.
• Inclusão de novas funções e exigências regulatórias afetando prazo e custo.

Palavras-chave:
aplicativo bancário, clínica, e-commerce, finanças pessoais, exemplo prático, escopo

---

6. Técnicas e ferramentas de levantamento

• Uso de:
  • entrevistas;
  • brainstorming;
  • workshops;
  • análise de feedback;
  • reuniões com stakeholders.
• Ferramentas citadas:
  • JIRA
  • Azure DevOps

Palavras-chave:
entrevistas, brainstorming, workshops, stakeholders, JIRA, Azure DevOps, coleta de requisitos

---

7. Metodologias ágeis x tradicionais

• As abordagens tradicionais fazem levantamento e documentação mais detalhados antes da implementação.
• No modelo em cascata, os requisitos são definidos antes de seguir para as próximas fases.
• As abordagens ágeis tendem a ser mais adaptáveis a mudanças.

Palavras-chave:
metodologias ágeis, metodologias tradicionais, modelo cascata, adaptação, documentação, flexibilidade

---

8. Segurança e conformidade

• O sistema deve proteger dados sensíveis.
• Medidas citadas:
  • autenticação em dois fatores;
  • criptografia de dados;
  • conformidade com normas como LGPD e, em exemplo internacional, HIPAA.

Palavras-chave:
segurança, autenticação, criptografia, LGPD, HIPAA, privacidade, proteção de dados

---

9. Gestão de mudanças em requisitos

• Mudanças podem surgir no meio do projeto e impactar:
  • escopo;
  • prazo;
  • custo;
  • recursos disponíveis.
• É importante ter um processo claro para:
  • documentar mudanças;
  • aprovar mudanças;
  • implementar mudanças;
  • comunicar impactos às partes interessadas.

Palavras-chave:
gestão de mudanças, escopo, prazo, custo, aprovação, documentação, impacto

---

10. Riscos no levantamento de requisitos

• Riscos podem comprometer a viabilidade do projeto.
• Técnicas citadas para identificar e avaliar riscos:
  • análise qualitativa;
  • análise quantitativa;
  • análise de cenários;
  • brainstorming;
  • checklists baseados em projetos anteriores.

Palavras-chave:
riscos, análise qualitativa, análise quantitativa, cenários, checklist, mitigação

---

11. Comunicação com stakeholders

• A comunicação eficaz é essencial durante o levantamento e a gestão de mudanças.
• É necessário:
  • compreender os stakeholders;
  • criar plano de comunicação;
  • negociar prioridades e impactos.

Palavras-chave:
comunicação, stakeholders, negociação, entendimento mútuo, plano de comunicação

---

Resumão final

O levantamento de requisitos é uma etapa fundamental do desenvolvimento de software, pois define o que o sistema deve fazer e como ele deve se comportar. Ele envolve técnicas de coleta, análise, documentação, validação e comunicação com as partes interessadas. Também exige atenção à segurança, à qualidade, aos riscos e à gestão de mudanças, para garantir que o projeto entregue valor real ao usuário e ao negócio.

B – Segundo Bloco

1. Conceito de testes funcionais

• Verificam se o software cumpre os requisitos definidos.
• Avaliam se o sistema se comporta como esperado para o usuário.
• Podem envolver teste de interface, APIs, banco de dados e fluxos do sistema.

Palavras-chave:
testes funcionais, requisitos, comportamento esperado, validação, conformidade

---

2. Objetivo principal dos testes funcionais

• Garantir que o software esteja de acordo com os requisitos funcionais.
• Identificar erros e comportamentos inesperados antes da entrega ao usuário.

Palavras-chave:
conformidade, requisitos funcionais, falhas, qualidade, validação

---

3. Etapas do processo de teste funcional

• Levantamento de requisitos
• Planejamento de teste
• Design de teste
• Preparação do ambiente de teste
• Execução de teste
• Registro de defeitos
• Relatório de teste

Palavras-chave:
levantamento, planejamento, design, ambiente de teste, execução, defeitos, relatório

---

4. Casos e cenários de teste

• Servem para verificar a cobertura dos requisitos.
• Devem considerar:
  • entradas válidas e inválidas;
  • resultado esperado;
  • funções relevantes do sistema.

Palavras-chave:
casos de teste, cenários de teste, cobertura, entradas válidas, entradas inválidas, resultado esperado

---

5. Caminho feliz e condições não ideais

• Um bom teste não cobre só o caminho feliz.
• Também deve avaliar:
  • erros;
  • exceções;
  • situações de uso não ideais;
  • comportamento sob carga ou condições difíceis.

Palavras-chave:
caminho feliz, exceções, erros, carga, robustez, confiabilidade

---

6. Metodologias tradicionais x ágeis

Tradicionais

• Processo mais sequencial.
• Testes acontecem depois do desenvolvimento.
• Menor flexibilidade para mudanças.
• Feedback mais lento.

Ágeis

• Processo iterativo e incremental.
• Testes ocorrem em paralelo ao desenvolvimento.
• Correções mais rápidas.
• Mais colaboração entre desenvolvedores e testadores.
• Maior adaptação a mudanças.

Palavras-chave:
tradicional, ágil, cascata, sprint, iteração, feedback, colaboração, flexibilidade

---

7. Teste funcional no desenvolvimento ágil

• Os testes são integrados em cada sprint.
• Testadores participam do planejamento.
• Critérios de aceitação precisam ser testáveis.
• Ajuda na identificação rápida de defeitos.
• Uso frequente de testes automatizados para regressão e novas funcionalidades.

Palavras-chave:
sprint, critérios de aceitação, defeitos, regressão, integração contínua, desenvolvimento ágil

---

8. Automação de testes funcionais

• Indicada para testes repetitivos e estáveis.
• Boa quando o custo manual é alto.
• Deve usar ferramentas compatíveis com a tecnologia da equipe.
• Não elimina testes manuais e exploratórios.

Palavras-chave:
automação, testes repetitivos, scripts reutilizáveis, testes manuais, testes exploratórios

---

9. Estratégias de teste

• Uma estratégia eficaz começa com:
  • análise de requisitos;
  • perfil de risco.
• O objetivo é priorizar áreas mais críticas e mais suscetíveis a falhas.

Palavras-chave:
estratégia de teste, análise de requisitos, perfil de risco, priorização, áreas críticas

---

10. Gerenciamento de dados de teste

• Pode usar:
  • dados sintéticos;
  • dados reais anonimizados.
• Os dados devem representar:
  • casos comuns;
  • casos limite;
  • situações reais do sistema.

Palavras-chave:
dados de teste, dados sintéticos, anonimização, casos limite, manutenção de dados

---

11. Ferramentas e tecnologias

• Automação de testes: Selenium, QTP, TestComplete
• Gestão de testes: JIRA, TestRail
• Integração contínua: Jenkins, Travis CI

Palavras-chave:
Selenium, QTP, TestComplete, JIRA, TestRail, Jenkins, Travis CI

---

12. Qualidade e testes

• Teste está ligado à qualidade do software.
• As melhores práticas reduzem erros e aumentam a confiança no produto final.
• A qualidade deve ser acompanhada ao longo do ciclo de desenvolvimento.

Palavras-chave:
qualidade, garantia de qualidade, melhores práticas, confiança, ciclo de desenvolvimento

---

13. Avaliação de riscos

• A equipe deve identificar e priorizar riscos:
  • técnicos;
  • de negócios;
  • de usabilidade.
• Depois, selecionar os principais riscos e propor ações preventivas.

Palavras-chave:
avaliação de risco, riscos técnicos, riscos de negócios, usabilidade, mitigação, priorização

---

Resumão final

Os testes funcionais garantem que o software entregue ao usuário esteja funcionando conforme os requisitos definidos. Eles envolvem planejamento, criação de cenários, execução, registro de defeitos e análise de resultados. No modelo ágil, os testes são contínuos e integrados às sprints. Além disso, a qualidade dos testes depende de boa estratégia, dados de teste adequados, automação bem aplicada e análise de riscos.

C – Terceiro bloco

1. O que são testes de software

• São processos usados para avaliar a qualidade do software.
• Verificam se o sistema atende aos critérios de exigência.
• Envolvem a execução do programa para encontrar erros e confirmar se o comportamento está conforme o esperado.

Palavras-chave:
testes de software, qualidade, erros, critérios de exigência, comportamento esperado

---

2. Importância dos testes

• Ajudam a garantir a qualidade da entrega.
• Evitam problemas na operação da empresa.
• Validam funcionalidades e ajudam a atender requisitos do usuário e expectativas do negócio.

Palavras-chave:
qualidade da entrega, operação, requisitos do usuário, expectativas do negócio, validação

---

3. Objetivos dos testes de software

• Verificação: confirmar que o software atende aos requisitos técnicos e funcionais.
• Validação: assegurar que atende às necessidades do usuário final.
• Descoberta de defeitos: identificar e documentar falhas.
• Garantia de qualidade: dar confiança aos stakeholders.
• Prevenção de defeitos: usar os resultados para evitar erros futuros.

Palavras-chave:
verificação, validação, defeitos, garantia de qualidade, prevenção de erros, stakeholders

---

4. Níveis de teste

• A aula destaca a diferenciação entre:
  • testes unitários;
  • testes de integração;
  • testes de sistema;
  • testes de aceitação.

Palavras-chave:
teste unitário, teste de integração, teste de sistema, teste de aceitação

---

5. Testes funcionais

• Verificam se o sistema está de acordo com os requisitos funcionais.
• O foco é testar as funcionalidades do software.
• Exemplo: em um e-commerce, verificar carrinho, cálculo do total, cupons e checkout.

Palavras-chave:
testes funcionais, funcionalidades, requisitos funcionais, carrinho, checkout

---

6. Testes não funcionais

• Avaliam aspectos como:
  • desempenho;
  • usabilidade;
  • confiabilidade;
  • segurança.
• Exemplo: testar carga de acessos simultâneos, segurança do pagamento e facilidade de navegação.

Palavras-chave:
testes não funcionais, desempenho, usabilidade, confiabilidade, segurança, carga

---

7. Testes automatizados

• Usam ferramentas para executar testes sem intervenção humana contínua.
• São úteis para tarefas repetitivas e grandes volumes de código.
• Exemplos citados:
  • Selenium;
  • JUnit.

Palavras-chave:
testes automatizados, automação, Selenium, JUnit, repetição, eficiência

---

8. Testes manuais

• São executados por testadores sem automação.
• São úteis em cenários mais complexos ou que exigem intuição humana.
• Têm mais flexibilidade para detectar problemas inesperados, embora sejam mais lentos.

Palavras-chave:
testes manuais, intuição humana, flexibilidade, cenários complexos, experiência do usuário

---

9. Testes de regressão

• Verificam se mudanças recentes no sistema afetaram negativamente funcionalidades já existentes.
• São importantes para identificar problemas sutis após alterações no código.
• Podem ser implementados com automação e integração contínua, usando ferramentas como:
  • GitLab CI/CD;
  • Jenkins.

Palavras-chave:
teste de regressão, mudança de código, funcionalidade existente, GitLab CI/CD, Jenkins

---

10. Plano de testes

As etapas destacadas para desenvolver um plano de testes são:

• análise de requisitos;
• definição de escopo;
• estratégia de testes;
• alocação de recursos;
• cronograma;
• gestão de riscos;
• critérios de entrada e saída.

Palavras-chave:
plano de testes, requisitos, escopo, estratégia, recursos, cronograma, riscos, critérios

---

11. Organização e priorização de casos de teste

Os casos de teste devem ser priorizados com base em:

• importância do negócio;
• frequência de uso;
• complexidade e risco;
• impacto da falha.

Palavras-chave:
priorização, casos de teste, importância do negócio, risco, impacto da falha

---

12. Métricas de teste

As aulas destacam o uso de métricas para medir o progresso e a eficácia dos testes, como:

• taxa de cobertura de teste;
• taxa de sucesso/falha;
• número de defeitos encontrados por ciclo;
• tempo médio para correção de defeitos.

Palavras-chave:
métricas, cobertura de teste, sucesso, falha, defeitos, progresso, eficácia

---

13. Exemplo prático apresentado

Foi usada uma aplicação de to-do list chamada TaskMaster para exercitar plano de testes. Os requisitos incluíam:

• criar tarefa;
• editar tarefa;
• excluir tarefa;
• marcar como completa;
• filtrar tarefas por status.

Palavras-chave:
TaskMaster, to-do list, criar tarefa, editar tarefa, excluir tarefa, completar tarefa, filtro

---

14. Ideia central das aulas

As aulas mostram que testar software não é só procurar erro: é também organizar estratégia, definir prioridades, medir resultados e garantir que o sistema funcione com qualidade e segurança.

Palavras-chave:
estratégia de teste, qualidade, segurança, organização, eficiência

---

Resumão final

Os testes de software existem para garantir que o sistema funcione corretamente, atenda aos requisitos e entregue qualidade ao usuário e ao negócio. Eles incluem testes funcionais, não funcionais, manuais, automatizados e de regressão. Além disso, um bom processo de teste depende de planejamento, priorização, métricas e gestão de riscos.

D – Quarto bloco

1. O que é modelagem de dados

• É o processo de definir, analisar e organizar os dados necessários para apoiar os processos de negócio.
• Os dados são mapeados para que possam ser armazenados em banco de dados.
• Ajuda a estruturar informações de forma útil, acessível e eficiente.

Palavras-chave:
modelagem de dados, organização dos dados, processos de negócio, banco de dados, estruturação

---

2. Importância da modelagem de dados

• Facilita a comunicação entre desenvolvedores e usuários de negócio.
• É fundamental para criar sistemas de informação eficientes.
• Busca garantir dados de alta qualidade, bem estruturados e prontos para uso.

Palavras-chave:
comunicação, usuários de negócio, qualidade dos dados, eficiência, sistemas de informação

---

3. Objetivos da modelagem de dados

• Representar visualmente as regras de negócio.
• Mostrar como os dados interagem entre si.
• Preparar a base para desenvolvimento, armazenamento e manutenção das informações.

Palavras-chave:
regras de negócio, interação entre dados, representação visual, manutenção, desenvolvimento

---

4. Tipos de modelos de dados

As aulas destacam três tipos principais:

a) Modelo conceitual

• É um modelo de alto nível.
• Foca na visão do negócio e nas necessidades iniciais do projeto.
• É usado para alinhar analistas e usuários finais sem entrar em detalhes técnicos.

Palavras-chave:
modelo conceitual, alto nível, visão do negócio, fase inicial, necessidades de negócio

b) Modelo lógico

• É mais detalhado que o conceitual.
• Define entidades, atributos e relacionamentos.
• Não se preocupa ainda com a forma física de armazenamento.

Palavras-chave:
modelo lógico, entidades, atributos, relacionamentos, estrutura do banco

c) Modelo físico

• Mostra como os dados serão armazenados de fato.
• Inclui detalhes técnicos como tabelas, colunas, índices, partições e estratégias de armazenamento.
• É usado para construir o banco real e otimizar desempenho.

Palavras-chave:
modelo físico, tabelas, colunas, índices, partições, desempenho, armazenamento

---

5. Normalização de dados

• É o processo de organizar os dados para reduzir redundância e melhorar a integridade.
• Envolve dividir tabelas grandes em tabelas menores e relacionadas.
• Ajuda na manutenção, consistência e evolução do banco de dados.

Palavras-chave:
normalização, redundância, integridade, consistência, tabelas relacionadas

---

6. Benefícios da normalização

• Diminui duplicidade de dados.
• Melhora a integridade dos dados.
• Facilita a manutenção e atualização.
• Torna o armazenamento mais eficiente.

Palavras-chave:
duplicidade, integridade, manutenção, eficiência, organização

---

7. SGBD – Sistemas de Gerenciamento de Banco de Dados

• São softwares usados para criar, manipular e interagir com bancos de dados.
• Funcionam com base em um modelo de dados e, geralmente, em uma linguagem de consulta como SQL.
• Exemplos citados:
  • MySQL
  • PostgreSQL
  • Oracle Database
  • Microsoft SQL Server
  • MongoDB

Palavras-chave:
SGBD, SQL, MySQL, PostgreSQL, Oracle, SQL Server, MongoDB

---

8. Modelos de dados quanto à tecnologia

Relacional

• Usa tabelas para representar dados e relações.
• Adequado para dados estruturados e consultas complexas.

NoSQL

• Permite armazenar dados em formatos menos rígidos.
• Pode ser orientado a documentos, colunar ou gráfico.

NewSQL

• Combina o modelo relacional com escalabilidade de sistemas NoSQL.
• Mantém propriedades ACID e é útil em ambientes com muitas transações.

Palavras-chave:
relacional, NoSQL, NewSQL, escalabilidade, ACID, consultas complexas

---

9. Integridade e segurança de dados

• Integridade significa precisão e consistência dos dados ao longo do tempo.
• Segurança protege contra acesso não autorizado, corrupção ou perda.

Práticas recomendadas:

• controle de acesso;
• criptografia em repouso e em trânsito;
• backups regulares;
• auditoria e monitoramento;
• validação e restrições de integridade.

Palavras-chave:
integridade, segurança, controle de acesso, criptografia, backup, auditoria, validação

---

10. Design de dados

• É a etapa que define como os dados serão armazenados, acessados e mantidos.
• Envolve metodologias como:
  • modelagem conceitual;
  • modelagem lógica;
  • normalização;
  • modelagem física.

Palavras-chave:
design de dados, armazenamento, acesso, manutenção, metodologias

---

11. Arquitetura de dados

• É o quadro que organiza dados, tecnologia, infraestrutura e serviços analíticos para atender às necessidades do negócio.

As aulas citam exemplos de arquitetura:

• arquitetura tradicional com data warehouse;
• data lakes para dados brutos e estruturados;
• arquitetura orientada a serviços com serviços de dados reutilizáveis.

Palavras-chave:
arquitetura de dados, data warehouse, data lake, serviços de dados, infraestrutura, analytics

---

12. Escalabilidade e futuro dos dados

• O design e a arquitetura de dados devem permitir que o sistema cresça e se adapte às mudanças do negócio.
• Tendências citadas:
  • Big Data e Analytics Avançado;
  • Internet das Coisas (IoT);
  • Blockchain;
  • Data as a Service (DaaS);
  • privacidade e conformidade, como LGPD.

Palavras-chave:
escalabilidade, Big Data, analytics, IoT, blockchain, DaaS, LGPD, conformidade

---

13. Exemplos práticos trabalhados nas aulas

• Inventário de empresa/e-commerce: criação de plano de modelagem com modelos conceitual, lógico e físico.
• Universidade: exemplo de modelagem conceitual com alunos, cursos e matrículas.
• E-commerce: exemplo de modelagem lógica com usuários, produtos, pedidos e pagamentos.
• Livraria on-line: atividade para definir entidades, atributos e relacionamentos.

Palavras-chave:
inventário, universidade, e-commerce, livraria on-line, entidades, atributos, relacionamentos

---

14. Ideia central das aulas

As aulas mostram que a modelagem de dados é a base para construir sistemas bem organizados, seguros, escaláveis e alinhados às necessidades do negócio. Ela começa em um nível mais abstrato, passa pelo detalhamento lógico e chega à implementação física, sempre com foco em qualidade, integridade e eficiência.

Palavras-chave:
base do sistema, organização, escalabilidade, integridade, eficiência, negócio

---

Resumão final

A modelagem de dados é o processo de planejar e estruturar os dados de um sistema. Ela envolve os modelos conceitual, lógico e físico, além de práticas como normalização, segurança, integridade e definição da arquitetura de dados. Tudo isso serve para garantir bancos de dados mais consistentes, eficientes e preparados para crescer com o negócio.

E – Quinto bloco

1. O que é UML

• UML significa Unified Modeling Language.
• É uma linguagem padrão de modelagem usada para visualizar, especificar, construir e documentar sistemas de software.
• Seu papel é criar uma linguagem comum entre todos os envolvidos no desenvolvimento.

Palavras-chave:
UML, linguagem padrão, modelagem, visualização, documentação, linguagem comum

---

2. Origem e evolução da UML

• Surgiu no início dos anos 1990, quando a modelagem orientada a objetos crescia, mas ainda sem padronização.
• A UML unificou métodos como:
  • Booch
  • OMT (Rumbaugh)
  • OOSE (Jacobson)
• A unificação começou com Booch e Rumbaugh na Rational Software, depois com Jacobson.
• A UML 1.0 virou padrão oficial em 1997, após adoção pela OMG.

Palavras-chave:
anos 1990, Booch, OMT, OOSE, Rational Software, OMG, padronização, evolução

---

3. Importância da UML

• Facilita a comunicação entre equipe técnica e stakeholders.
• Ajuda na documentação de software.
• Apoia o entendimento da estrutura e do comportamento do sistema.
• Serve como ponte entre ideia, projeto, implementação e manutenção.

Palavras-chave:
comunicação, stakeholders, documentação, entendimento, manutenção, desenvolvimento

---

4. Elementos básicos da UML

Os principais elementos citados são:

a) Classes

• Representam entidades ou conceitos.
• Possuem atributos e operações/métodos.

b) Objetos

• São instâncias das classes em tempo de execução.

c) Relacionamentos

• Conexões entre classes e objetos.
• Exemplos:
  • associação
  • generalização/herança
  • dependência

d) Diagramas

• Representações gráficas dos elementos e de seus relacionamentos.

Palavras-chave:
classes, objetos, atributos, métodos, relacionamentos, associação, herança, dependência, diagramas

---

5. Diagramas de caso de uso

• Representam as funcionalidades do sistema sob a perspectiva do usuário.
• Mostram a interação entre o sistema e os atores.
• Cada caso de uso é representado por uma elipse.
• A ligação entre ator e caso de uso é feita por linha sólida.
• Pode haver relações de inclusão e extensão entre casos de uso.

Palavras-chave:
caso de uso, ator, funcionalidade, perspectiva do usuário, elipse, inclusão, extensão

---

6. Diagramas de classe

• São o pilar da modelagem orientada a objetos.
• Representam a estrutura estática do sistema.
• Mostram:
  • nome da classe;
  • atributos;
  • métodos/operações;
  • relações entre classes.
• As classes aparecem em caixas divididas em três partes.
• A herança é mostrada com seta vazada para a classe pai.
• Associações são mostradas com linhas sólidas.

Palavras-chave:
diagrama de classe, estrutura estática, atributos, métodos, herança, associação, caixa de classe

---

7. Diagramas de sequência

• Mostram como os objetos interagem ao longo do tempo.
• Representam a sequência temporal das mensagens trocadas entre objetos.
• Usam:
  • linhas verticais para participantes;
  • setas horizontais para mensagens.

Palavras-chave:
diagrama de sequência, interação, sequência temporal, mensagens, participantes

---

8. Diagramas de colaboração

• Também chamados de diagramas de comunicação.
• Focam a organização estrutural dos objetos que interagem.
• São parecidos com os diagramas de sequência, mas destacam mais a relação entre objetos do que a ordem temporal.

Palavras-chave:
diagrama de colaboração, diagrama de comunicação, organização estrutural, interação entre objetos

---

9. Diagramas de atividade

• Representam fluxos de trabalho e processos de negócio.
• Mostram:
  • início do processo;
  • atividades;
  • decisões;
  • transições;
  • término do processo.

Elementos técnicos

• nó inicial e final
• atividades
• decisões
• sincronização e concorrência
• transições com guardas

Palavras-chave:
diagrama de atividade, fluxo de trabalho, processo de negócio, decisão, transição, concorrência, guarda

---

10. Diagramas de estado

• Capturam os diferentes estados de um objeto ao longo do seu ciclo de vida.
• Mostram as transições entre estados.
• São úteis para modelar objetos dinâmicos com comportamentos diferentes em cada fase.

Elementos técnicos

• estados
• transições
• eventos
• ações
• estado inicial e final

Palavras-chave:
diagrama de estado, ciclo de vida, estados, transições, eventos, ações

---

11. Diagramas de componentes e implantação

• As aulas apontam esses diagramas como importantes para representar a arquitetura e a organização dos componentes físicos do software.

Palavras-chave:
diagramas de componentes, implantação, arquitetura, componentes físicos, organização

---

12. UML no ciclo de vida do software

• A UML pode ser usada desde a concepção das ideias até:
  • análise;
  • projeto;
  • implementação;
  • documentação;
  • manutenção.
• Cada tipo de diagrama ajuda a enxergar um aspecto diferente do sistema.

Palavras-chave:
ciclo de vida, análise, projeto, implementação, manutenção, documentação

---

13. UML no desenvolvimento ágil

• No ágil, a UML é usada de forma seletiva.
• O foco não é documentação extensa, mas comunicação rápida e clara.
• Pode ser usada em:
  • planejamento de sprint;
  • discussão com stakeholders;
  • esclarecimento de fluxos e funcionalidades.

Palavras-chave:
desenvolvimento ágil, comunicação rápida, sprint, stakeholders, documentação leve

---

14. Exemplos práticos citados

• Pedido online: seleção de produtos, checkout, pagamento e confirmação em diagrama de atividade.
• Leilão online: escolha do produto, lance, validação do maior lance e envio de notificações.
• Resgate de senha em e-commerce: solicitar recuperação, enviar e-mail, clicar no link e criar nova senha.

Palavras-chave:
pedido online, leilão online, resgate de senha, e-commerce, fluxo, notificação

---

15. Ideia central das aulas

As aulas mostram que a UML é uma ferramenta essencial para entender, comunicar, documentar e projetar software, usando diferentes diagramas para representar estrutura, comportamento, interação e fluxo do sistema.

Palavras-chave:
estrutura, comportamento, interação, fluxo, documentação, comunicação, projeto

---

Resumão final

A UML é uma linguagem padrão de modelagem que ajuda a representar sistemas de software de forma visual e organizada. Seus principais elementos são classes, objetos, relacionamentos e diagramas. Entre os diagramas mais importantes estão os de caso de uso, classe, sequência, colaboração, atividade e estado. Ela pode ser usada tanto em processos tradicionais quanto no desenvolvimento ágil, sempre ajudando na comunicação, documentação e compreensão do sistema.

F – Sexto Bloco

1. O que é POO

• A programação orientada a objetos é um paradigma baseado na criação de objetos.
• Esses objetos unem dados (estado) e comportamentos (ações/métodos).
• A POO ajuda a criar programas mais fáceis de entender, modificar e manter.

Palavras-chave:
POO, paradigma, objetos, estado, comportamento, manutenção, organização

---

2. Fundamentos básicos da POO

• Os conceitos centrais apresentados são:
  • classes;
  • objetos;
  • atributos;
  • métodos.

Palavras-chave:
classes, objetos, atributos, métodos, estrutura, comportamento

---

3. Classe

• A classe é o molde ou modelo usado para criar objetos.
• Ela descreve características e comportamentos que os objetos terão.
• Exemplo da aula: a classe Automóvel define marca, modelo, cor e ações como acelerar e frear.

Palavras-chave:
classe, molde, modelo, automóvel, características, comportamentos

---

4. Objeto

• O objeto é a instância concreta criada a partir de uma classe.
• É a representação real de algo descrito pela classe.
• Exemplo: um Ford Mustang vermelho de 2020 é um objeto da classe Automóvel.

Palavras-chave:
objeto, instância, exemplo concreto, instanciamento, automóvel

---

5. Método

• Os métodos representam as ações que os objetos podem executar.
• Funcionam como funções dentro da classe.
• Exemplo: ligarMotor, acelerar, frear, exibirDetalhes.

Palavras-chave:
método, ação, comportamento, função, operação

---

6. Quatro pilares da POO

A POO é baseada em quatro princípios fundamentais:

a) Encapsulamento

• Protege os dados internos do objeto.
• O acesso ocorre por meio de métodos definidos.
• Ajuda a evitar estados inconsistentes.

Palavras-chave:
encapsulamento, proteção de dados, controle de acesso, integridade

b) Abstração

• Simplifica a complexidade do mundo real.
• Foca no que é essencial e ignora detalhes menos importantes.

Palavras-chave:
abstração, simplificação, foco no essencial, complexidade

c) Herança

• Permite que uma classe herde características e comportamentos de outra.
• Favorece reutilização de código e organização hierárquica.

Palavras-chave:
herança, reutilização, classe pai, classe filha, hierarquia

d) Polimorfismo

• Permite usar uma interface comum para objetos diferentes.
• Cada objeto pode responder de forma própria ao mesmo método.

Palavras-chave:
polimorfismo, interface comum, respostas diferentes, flexibilidade

---

7. Benefícios da POO

• Reutilização de código
• Modularidade
• Facilidade de manutenção
• Melhor organização
• Solução de problemas complexos

Palavras-chave:
reutilização, modularidade, manutenção, organização, flexibilidade

---

8. POO e mundo real

• A POO incentiva pensar em objetos do mundo real durante o desenvolvimento.
• Isso torna o projeto mais intuitivo e mais alinhado ao problema que se quer resolver.

Palavras-chave:
mundo real, modelagem, intuição, domínio do problema

---

9. Divisão de contexto em classes

• As aulas mostram como pegar um problema real e separar em classes.
• Exemplo trabalhado:
  • Cliente
  • Pedido
  • Produto
  • Pagamento
• Também é importante definir:
  • atributos;
  • métodos;
  • relacionamentos entre classes.

Palavras-chave:
análise de contexto, classes, cliente, pedido, produto, pagamento, relacionamentos

---

10. Design orientado a objetos

• É a organização do sistema com base em objetos e classes.
• Serve para planejar software de forma mais robusta e manutenível.

Palavras-chave:
design orientado a objetos, planejamento, organização, robustez, manutenção

---

11. Padrões de projeto

São soluções típicas para problemas recorrentes em design de software. As aulas citam três grupos:

a) Criacionais

• Relacionados à criação de objetos.
• Exemplos: Singleton, Factory, Builder.

b) Estruturais

• Relacionados à composição de classes e objetos.
• Exemplos: Adapter, Decorator, Composite.

c) Comportamentais

• Relacionados à comunicação e responsabilidade entre objetos.
• Exemplos: Observer, Strategy, Command.

Palavras-chave:
padrões de projeto, criacionais, estruturais, comportamentais, Singleton, Factory, Observer

---

12. Princípios SOLID

As aulas apresentam os cinco princípios SOLID para construir sistemas mais compreensíveis, flexíveis e manuteníveis:

• S – Responsabilidade Única
• O – Aberto/Fechado
• L – Substituição de Liskov
• I – Segregação de Interface
• D – Inversão de Dependência

Palavras-chave:
SOLID, responsabilidade única, aberto/fechado, Liskov, segregação de interface, inversão de dependência

---

13. Refatoração e testes em POO

• A aplicação prática da POO também envolve:
  • refatoração de código;
  • testes unitários;
  • uso de mock para validar a lógica dos objetos.

Palavras-chave:
refatoração, testes unitários, mock, qualidade, validação

---

14. Aplicação prática

• A terceira aula mostra que os pilares da POO ajudam a construir sistemas:
  • flexíveis;
  • manuteníveis;
  • preparados para evoluir com novas demandas.

Palavras-chave:
sistemas flexíveis, manuteníveis, evolução, longo prazo

---

Resumão final

A programação orientada a objetos organiza o software com base em classes e objetos, reunindo atributos e métodos. Seus quatro pilares são encapsulamento, abstração, herança e polimorfismo. Além disso, a POO se conecta com design orientado a objetos, padrões de projeto, SOLID, refatoração e testes, tudo para criar sistemas mais organizados, reutilizáveis e fáceis de manter.

G- Setimo bloco

1. O que é elicitação de requisitos

• É o processo de coletar requisitos do cliente, dos usuários e das demais partes interessadas.
• É uma das fases mais críticas do desenvolvimento de software.
• Seu objetivo é garantir que os requisitos sejam completos, claros e validados.

Palavras-chave:
elicitação de requisitos, coleta, cliente, usuários, requisitos claros, requisitos validados

---

2. Importância da elicitação

• Define o que será necessário para o projeto ter sucesso.
• Ajuda a entender as necessidades reais do negócio e dos usuários.
• Reduz riscos, falhas de comunicação e retrabalho.

Palavras-chave:
sucesso do projeto, necessidades do negócio, entendimento, alinhamento, redução de riscos

---

3. Tipos de requisitos

As aulas destacam três tipos principais:

a) Requisitos de usuário

• São descritos em linguagem natural e diagramas.
• Focam no que o usuário precisa e espera do sistema.
• Devem ser compreensíveis por todos os envolvidos.

b) Requisitos de sistema

• São mais técnicos e detalhados.
• Servem como guia para a equipe de desenvolvimento construir o sistema.

c) Requisitos funcionais

• Especificam o comportamento interno do sistema.
• Descrevem o que o sistema fará em determinadas condições ou entradas.

Palavras-chave:
requisitos de usuário, requisitos de sistema, requisitos funcionais, linguagem natural, detalhamento técnico

---

4. Técnicas de elicitação

As técnicas mais citadas são:

a) Entrevistas

• Conversas diretas com stakeholders.
• Permitem entender necessidades, expectativas e até conhecimentos tácitos.
• São flexíveis e profundas, pois o entrevistador pode adaptar as perguntas em tempo real.

b) Questionários

• Conjunto de perguntas escritas para coletar respostas de muitas pessoas.
• Úteis para obter uma variedade maior de necessidades e opiniões.

c) Workshops

• Reuniões colaborativas com vários stakeholders.
• Servem para discutir, definir e alinhar requisitos.

d) Observação

• Consiste em analisar o ambiente de trabalho do usuário e como ele executa suas tarefas.
• Ajuda a identificar requisitos que nem sempre são verbalizados.

Palavras-chave:
entrevistas, questionários, workshops, observação, stakeholders, conhecimento tácito

---

5. Validação de requisitos

• Serve para confirmar se os requisitos realmente refletem as necessidades dos stakeholders.
• Também verifica se os requisitos são técnica e economicamente viáveis.
• Pode envolver revisão com usuários e uso de protótipos.

Palavras-chave:
validação, necessidades dos stakeholders, viabilidade técnica, viabilidade econômica, revisão, protótipos

---

6. Negociação de requisitos

• Nem todos os requisitos podem ser atendidos por limitações de:
  • tempo;
  • custo;
  • tecnologia.
• Por isso, é necessário discutir prioridades e resolver conflitos entre stakeholders.

Palavras-chave:
negociação, prioridades, restrições, custo, tempo, conflitos, alinhamento

---

7. Modelagem e prototipagem

• São técnicas usadas na elicitação e validação.
• Ajudam a visualizar e testar funcionalidades antes da implementação completa.

Modelagem

• Cria representações abstratas do sistema.
• Exemplos:
  • diagrama de fluxo de dados;
  • modelo entidade-relacionamento;
  • diagrama de caso de uso.

Prototipagem

• Desenvolve uma versão inicial limitada do sistema.
• Pode variar de wireframes e mockups até sistemas parcialmente funcionais.
• Facilita o feedback dos usuários.

Palavras-chave:
modelagem, prototipagem, visualização, wireframe, mockup, caso de uso, feedback

---

8. Análise de stakeholders

• É o processo de identificar quem pode afetar ou ser afetado pelo projeto.
• Busca entender:
  • interesses;
  • expectativas;
  • influência;
  • impacto no projeto.

Etapas principais

• Identificação dos stakeholders;
• Envolvimento de cada parte no momento adequado;
• Análise de necessidades, expectativas e poder de influência.

Palavras-chave:
análise de stakeholders, identificação, envolvimento, influência, impacto, prioridades

---

9. Elicitação em metodologias ágeis

• Nas metodologias ágeis, a elicitação é um processo contínuo, colaborativo e iterativo.
• Ela acontece ao longo dos ciclos curtos de desenvolvimento, como as sprints.

Elementos citados

• User Stories: descrições curtas das funcionalidades na perspectiva do usuário.
• Backlog Grooming: refinamento e priorização contínua dos requisitos.
• Iterações curtas: permitem ajustes frequentes.
• Feedback contínuo: incorpora mudanças ao longo do projeto.

Palavras-chave:
metodologias ágeis, sprints, user stories, backlog grooming, iteração, feedback contínuo

---

10. Comunicação na elicitação

• A comunicação eficaz é essencial para alinhar expectativas e entender o projeto profundamente.
• Ajuda a minimizar:
  • riscos;
  • mal-entendidos;
  • conflitos.

Palavras-chave:
comunicação, alinhamento, expectativas, mal-entendidos, colaboração, riscos

---

11. Habilidades de comunicação importantes

As aulas destacam:

• escuta ativa;
• comunicação não verbal;
• feedback construtivo;
• adaptação de linguagem;
• clareza e concisão;
• uso de ferramentas visuais.

Palavras-chave:
escuta ativa, comunicação não verbal, feedback construtivo, clareza, concisão, linguagem adequada

---

12. Workshops de requisitos

• São sessões estruturadas com stakeholders para definir e concordar com requisitos.
• Exigem:
  • preparação com objetivos claros;
  • seleção dos participantes;
  • agenda definida;
  • facilitação durante a reunião.

Palavras-chave:
workshops de requisitos, sessões estruturadas, facilitação, agenda, participação, consenso

---

13. Gerenciamento de conflitos

• Conflitos são comuns porque diferentes stakeholders têm visões, necessidades e prioridades diferentes.
• A gestão de conflitos envolve:
  • reconhecer o conflito;
  • compreender as posições das partes;
  • buscar entendimento mútuo.

Palavras-chave:
gerenciamento de conflitos, prioridades diferentes, reconhecimento, compreensão, entendimento mútuo

---

14. Exemplos práticos das aulas

Evento de treinamento interno

• Foi proposta uma atividade em que um e-mail incompleto exigia levantamento adicional de requisitos.
• O aluno deveria montar questionário, fluxo simples do evento e protótipo de agenda.

Projeto X com conflito entre equipes

• Um exemplo mostrou conflito entre desenvolvimento e marketing:
  • desenvolvimento queria mais tempo para funções técnicas avançadas;
  • marketing queria lançamento antes da temporada de festas.
• O exercício pedia um plano de ação para reconciliar requisitos conflitantes.

Palavras-chave:
evento, questionário, agenda, fluxo, conflito entre equipes, plano de ação, priorização

---

15. Ideia central das aulas

As aulas mostram que elicitar requisitos não é só perguntar o que o sistema deve fazer. Também envolve entender pessoas, contexto, prioridades, comunicação, conflitos e mudanças, usando técnicas adequadas para transformar necessidades em requisitos úteis e viáveis.

Palavras-chave:
pessoas, contexto, prioridades, viabilidade, comunicação, colaboração, requisitos úteis

---

Resumão final

A elicitação de requisitos é a etapa de descobrir, entender e organizar o que o sistema precisa entregar. Para isso, usa técnicas como entrevistas, questionários, workshops, observação, modelagem e prototipagem. Também depende de validação, negociação, análise de stakeholders, comunicação eficiente e gerenciamento de conflitos, especialmente em ambientes ágeis, onde os requisitos evoluem continuamente.

H – Bloco final

1. O que é modelagem de dados relacional

• É a base de quase todos os bancos de dados empresariais.
• Serve para estruturar dados de forma eficiente e alinhada às necessidades de informação da organização.
• Sua função é organizar entidades, atributos, chaves e relacionamentos.

Palavras-chave:
modelagem relacional, banco de dados, estrutura de dados, organização, eficiência

---

2. Entidades

• Uma entidade representa um objeto ou conceito do mundo real com existência independente.
• Exemplos citados:
  • estudante;
  • professor;
  • curso;
  • aluno.
• As entidades são os blocos básicos da modelagem relacional.

Palavras-chave:
entidade, objeto do mundo real, existência independente, bloco básico

---

3. Atributos

• Atributos são as características que descrevem uma entidade.
• Cada atributo armazena um tipo específico de dado, como:
  • texto;
  • número;
  • data;
  • binário.
• Exemplo:
  • Estudante: nome, ID, curso, data de nascimento;
  • Curso: nome do curso, código, departamento, créditos.

Palavras-chave:
atributos, propriedades, características, dados, nome, ID, data

---

4. Relação entre entidades e atributos

• A entidade é o objeto principal.
• Os atributos são os dados que descrevem esse objeto.
• Em outras palavras, entidades representam coisas; atributos representam informações sobre essas coisas.

Palavras-chave:
entidade e atributo, descrição, representação, informação

---

5. Chave primária

• A chave primária identifica de forma única cada registro de uma tabela.
• Pode ser formada por um atributo ou conjunto de atributos.
• Deve ser:
  • única;
  • obrigatória;
  • exclusiva para cada entidade.
• Exemplo: ID do estudante.

Palavras-chave:
chave primária, identificação única, registro, unicidade, obrigatoriedade

---

6. Chave estrangeira

• A chave estrangeira é um atributo em uma tabela que referencia a chave primária de outra tabela.
• Ela cria a ligação entre tabelas e viabiliza os relacionamentos.
• Exemplo: na tabela Estudante, o campo ID do Curso pode ser chave estrangeira.

Palavras-chave:
chave estrangeira, referência, ligação entre tabelas, relacionamento

---

7. Normalização de dados

• É o processo de organizar dados em tabelas e relações para:
  • minimizar redundância;
  • reduzir dependências indevidas;
  • melhorar a estrutura do banco.
• É realizada em etapas chamadas formas normais (1NF, 2NF, 3NF etc.).

Palavras-chave:
normalização, redundância, dependência, formas normais, organização

---

8. Objetivo da normalização

• Evitar duplicidade de dados.
• Reduzir inconsistências.
• Tornar as relações entre tabelas mais eficientes.

Palavras-chave:
duplicidade, inconsistência, eficiência, estrutura relacional

---

9. Tipos de relacionamentos

No modelo entidade-relacionamento, os relacionamentos são classificados em três tipos principais.

a) Um-para-Um (1:1)

• Uma entidade se relaciona com, no máximo, uma entidade da outra tabela.
• Exemplo: Pessoa e Passaporte.

Palavras-chave:
um-para-um, 1:1, pessoa, passaporte

b) Um-para-Muitos (1:N)

• Uma entidade pode estar associada a várias entidades da outra tabela.
• Exemplo: Professor e Curso. Um professor pode ministrar vários cursos, mas cada curso tem apenas um professor.

Palavras-chave:
um-para-muitos, 1:N, professor, curso

c) Muitos-para-Muitos (N:N)

• Uma entidade pode se relacionar com várias da outra tabela, e vice-versa.
• Exemplo: Alunos e Cursos.

Palavras-chave:
muitos-para-muitos, N:N, alunos, cursos

---

10. Tabela de associação

• Em relacionamentos muitos-para-muitos, normalmente é necessária uma tabela de associação.
• Exemplo:
  • Matrículas ligando Aluno e Curso.
• Essa tabela contém:
  • chaves estrangeiras das duas entidades;
  • atributos próprios da relação.

Palavras-chave:
tabela de associação, matrículas, relacionamento N:N, chaves estrangeiras

---

11. Atributos da associação

• A tabela de associação também pode guardar informações da própria relação.
• Exemplo de atributos:
  • DataDeMatricula;
  • NotaFinal.
• Isso permite registrar dados específicos do vínculo entre as entidades.

Palavras-chave:
atributos da associação, data de matrícula, nota final, vínculo

---

12. Integridade referencial

• Garante a consistência e validade dos relacionamentos entre tabelas.
• Se uma tabela A possui chave estrangeira apontando para tabela B, então o valor dessa chave deve existir como chave primária em B.
• Isso evita registros órfãos.

Palavras-chave:
integridade referencial, consistência, validade, registro órfão, relacionamento

---

13. Cascade delete e cascade update

• Alterações ou exclusões em uma tabela relacionada devem considerar as dependências entre tabelas.
• Restrições como:
  • cascade delete;
  • cascade update
    ajudam a manter a integridade dos dados.

Palavras-chave:
cascade delete, cascade update, integridade, dependência entre tabelas

---

14. MER e DER

• O conteúdo trabalha com o Modelo Entidade-Relacionamento (MER) e sua representação em diagramas.
• O MER é usado para representar:
  • entidades;
  • atributos;
  • relacionamentos;
  • associações.

Palavras-chave:
MER, DER, diagrama entidade-relacionamento, representação gráfica

---

15. Desnormalização

• É o processo inverso da normalização.
• Reintroduz deliberadamente redundância para melhorar o desempenho das leituras.
• Pode ser útil quando:
  • há muitas junções complexas;
  • o sistema faz mais leitura que escrita;
  • os dados mudam pouco.

Palavras-chave:
desnormalização, redundância controlada, desempenho, leitura, junções

---

16. Como aplicar desnormalização

• Combinar tabelas frequentemente usadas juntas.
• Adicionar colunas redundantes para acesso rápido.
• Pré-agregar dados, como:
  • somas;
  • médias;
  • totais para dashboards e relatórios.

Palavras-chave:
pré-agregação, consolidação, coluna redundante, dashboard, relatórios

---

17. Indexação e performance

• Índices são estruturas criadas para acelerar a busca de registros.
• Funcionam como um “sumário” dos dados.
• São úteis principalmente em colunas usadas em:
  • WHERE;
  • JOIN;
  • ORDER BY;
  • GROUP BY.

Palavras-chave:
índices, performance, velocidade, busca, WHERE, JOIN, ORDER BY, GROUP BY

---

18. Cuidados com indexação

• Índices demais podem prejudicar:
  • inserções;
  • atualizações;
  • exclusões.
• Isso acontece porque os índices também precisam ser atualizados.

Palavras-chave:
indexação excessiva, inserção, atualização, exclusão, custo de manutenção

---

19. Modelagem para Big Data

• Big Data exige adaptação da modelagem tradicional por causa de:
  • grande volume;
  • alta velocidade;
  • maior complexidade dos dados.
• Em muitos casos, são usados bancos NoSQL, como:
  • MongoDB;
  • Cassandra.

Palavras-chave:
Big Data, NoSQL, MongoDB, Cassandra, escalabilidade, esquemas flexíveis

---

20. Escalabilidade

• A modelagem para Big Data deve considerar crescimento horizontal e distribuição dos dados em vários servidores desde o início.

Palavras-chave:
escalabilidade, crescimento horizontal, distribuição de dados, servidores

---

21. Ideia central das aulas

As aulas mostram que a modelagem relacional começa com entidades, atributos, chaves e relacionamentos, passa pela normalização e integridade referencial, e depois evolui para preocupações mais avançadas, como desempenho, indexação, desnormalização e adaptação para Big Data.

Palavras-chave:
entidades, atributos, relacionamentos, normalização, integridade, performance, escalabilidade

---

Resumão final

A modelagem de dados relacional organiza informações em entidades, atributos e relacionamentos, usando chaves primárias e estrangeiras para ligar tabelas e garantir integridade referencial. Os relacionamentos podem ser 1:1, 1:N e N:N, sendo que o último normalmente exige tabela de associação. Além disso, o banco pode ser otimizado com normalização, desnormalização, índices e adaptações para Big Data, sempre buscando equilíbrio entre consistência, desempenho e escalabilidade.

Jargões e extrangeirismos

1. Termos de requisitos e trabalho em equipe

• Stakeholders: partes interessadas no projeto, como clientes, usuários, equipe e gestores.
• Workshop: sessão estruturada de trabalho em grupo para discutir e definir requisitos.
• Brainstorming: técnica de geração rápida de ideias para levantar possibilidades, problemas ou requisitos.
• Feedback: retorno, opinião ou resposta dada sobre uma ideia, requisito ou protótipo.

Palavras-chave: stakeholders, workshop, brainstorming, feedback

2. Termos ágeis

• Sprint: ciclo curto de desenvolvimento em metodologias ágeis.
• User Stories: histórias de usuário; descrições curtas de funcionalidades do ponto de vista do usuário.
• Backlog: lista priorizada de tarefas, requisitos e funcionalidades do projeto.
• Backlog Grooming: refinamento contínuo do backlog, para revisar, esclarecer e priorizar itens.
• Frameworks: estruturas ou conjuntos de ferramentas/práticas que apoiam o desenvolvimento.

Palavras-chave: sprint, user stories, backlog, backlog grooming, frameworks

3. Termos de prototipagem e interface

• Wireframe: esboço simples da tela, mostrando estrutura e organização visual sem preocupação com acabamento.
• Mockup: modelo visual mais detalhado da interface, mais próximo da aparência final.
• UI (User Interface): interface do usuário, ou seja, a parte visual e interativa do sistema.
• UI/UX: interface do usuário e experiência do usuário. Nos PDFs, aparece ligada a decisões visuais e de uso.
• Checkout: etapa final de compra em um e-commerce, quando o usuário fecha o pedido/pagamento.

Palavras-chave: wireframe, mockup, UI, UX, checkout

4. Termos de modelagem e UML

• UML (Unified Modeling Language): linguagem padrão de modelagem usada para visualizar e documentar sistemas.
• OMT (Object-Modeling Technique): método de modelagem orientada a objetos citado na origem da UML.
• OOSE (Object-Oriented Software Engineering): outra abordagem orientada a objetos que ajudou a formar a UML.
• Design: projeto ou concepção da estrutura do software ou dos dados.
• Links: no contexto de UML, ligações entre elementos/objetos.

Palavras-chave: UML, OMT, OOSE, design, links

5. Termos de banco de dados e dados

• SQL: linguagem usada para consultar e manipular bancos de dados relacionais; aparece associada aos SGBDs.
• NoSQL: grupo de bancos de dados com estrutura menos rígida que a relacional.
• NewSQL: modelo que mistura características relacionais com escalabilidade típica de sistemas mais modernos.
• ACID: conjunto de propriedades de confiabilidade em transações de banco de dados.
• Data warehouse: repositório centralizado para armazenamento e análise de dados.
• Data lake: armazenamento de grande volume de dados brutos e estruturados em um local central.
• Dashboard: painel visual com indicadores, gráficos e resumos de dados.
• Big Data: grande volume de dados, com alta complexidade e necessidade de processamento escalável.
• Analytics: análise de dados para gerar padrões, insights e apoio à decisão.
• DaaS (Data as a Service): dados oferecidos como serviço, geralmente por nuvem e sob demanda.
• IoT (Internet of Things): internet das coisas; dispositivos conectados gerando e trocando dados.
• Blockchain: tecnologia de registro distribuído e imutável usada para garantir integridade de transações/dados.
• Compliance / conformidade: aderência a normas, leis e regulamentos sobre dados. Nos PDFs, aparece junto de privacidade e LGPD.

Palavras-chave: SQL, NoSQL, NewSQL, ACID, data warehouse, data lake, dashboard, Big Data, analytics, DaaS, IoT, blockchain, compliance

6. Termos de testes de software

• Selenium: ferramenta de automação de testes de interface em navegadores web.
• JUnit: framework usado principalmente para testes unitários em aplicações Java.
• JMeter: ferramenta voltada mais para testes de carga e desempenho.
• LoadRunner: ferramenta de teste de desempenho e carga.
• QTP e TestComplete: ferramentas citadas para automação de testes.
• JIRA e TestRail: ferramentas para gestão e rastreamento de testes.
• Jenkins e Travis CI: ferramentas de integração contínua usadas para executar testes automaticamente no processo de desenvolvimento.
• CI/CD: integração contínua e entrega/implantação contínua. Os PDFs citam CI e CD como tecnologias usadas em desenvolvimento ágil.
• Slack: ferramenta de comunicação usada no exemplo de reportar riscos.

Palavras-chave: Selenium, JUnit, JMeter, LoadRunner, QTP, TestComplete, JIRA, TestRail, Jenkins, Travis CI, CI/CD, Slack

7. Termos de POO e padrões de projeto

• Singleton: padrão de projeto para garantir uma única instância de uma classe.
• Factory: padrão para centralizar/criar objetos de forma flexível.
• Builder: padrão usado para construir objetos complexos em etapas.
• Adapter: padrão que adapta uma interface para outra.
• Decorator: padrão que adiciona responsabilidades/comportamentos a objetos.
• Composite: padrão para tratar objetos individuais e compostos de forma uniforme.
• Observer: padrão em que um objeto observa mudanças em outro.
• Strategy: padrão para trocar algoritmos/comportamentos sem alterar o restante do código.
• Command: padrão que encapsula uma ação/comando em um objeto.
• SOLID: conjunto de princípios de design orientado a objetos para tornar o software mais organizado e manutenível.

Palavras-chave: Singleton, Factory, Builder, Adapter, Decorator, Composite, Observer, Strategy, Command, SOLID

8. Jargões técnicos em português que aparecem junto

Além das palavras estrangeiras, os PDFs usam bastante jargão técnico em português, como integridade referencial, normalização, desnormalização, escalabilidade, prototipagem, caso de uso, teste de regressão, confiabilidade e usabilidade. Esses termos não são estrangeiros, mas são linguagem técnica própria da área.

Resumão final

Os PDFs misturam bastante inglês técnico da área de TI com jargão profissional em português. Os grupos que mais aparecem são: ágil (sprint, backlog, feedback), requisitos (stakeholders, workshop, brainstorming), interface/protótipo (wireframe, mockup, UI/UX), dados (SQL, NoSQL, Big Data, dashboard) e testes/automação (Selenium, Jenkins, CI/CD).

Aula de Manipulação de dados em Python

Arquivos CSV

Um arquivo CSV (Comma-Separated Values) é um formato simples e muito usado para armazenar e trocar dados em forma de tabela. Nele, cada linha representa um registro e cada coluna é separada por vírgula (,), ponto e vírgula (;) ou outro delimitador.

✨ Principais características:

• É um arquivo de texto puro, fácil de abrir em qualquer editor ou programa.
• Pode ser lido e escrito por diversos sistemas e linguagens de programação.
• É amplamente usado para importar e exportar dados entre bancos de dados, planilhas (como Excel) e softwares.

📌 Exemplo de CSV:

nome,idade,cidade
Maria,25,São Paulo
João,30,Rio de Janeiro
Ana,22,Belo Horizonte

👉 Nesse exemplo:

• A primeira linha traz o cabeçalho (nomes das colunas).
• As linhas seguintes são os dados.

💡 Por ser simples e leve, o CSV é ideal quando precisamos de compatibilidade e portabilidade de dados, mas não traz recursos avançados como fórmulas ou formatação, presentes em arquivos de planilha.

Como criar um arquivo CSV

Entre no notepad++ e crie um novo arquivo.

Copie o seguinte conteúdo.

nome,idade,cidade
Maria,25,São Paulo
João,30,Rio de Janeiro
Ana,22,Belo Horizonte

Em seguida salve como listagem.csv

Pronto voce tem um arquivo csv válido.

Usando o Pandas

Pandas é uma biblioteca do Python muito usada para análise e manipulação de dados. Ele facilita o trabalho com tabelas, planilhas e arquivos CSV, oferecendo estruturas como DataFrame (que parece uma tabela do Excel dentro do Python).

📌 Explicação simplificada:

• O pandas permite ler arquivos CSV com apenas um comando.
• Depois de carregado, os dados ficam em um DataFrame, onde podemos visualizar, filtrar, ordenar e até realizar cálculos.
• É uma das bibliotecas mais usadas em ciência de dados e análise de dados.

---

Exemplo em Python usando o listagem.csv:

import pandas as pd

# Lê o arquivo CSV
df = pd.read_csv("listagem.csv")

# Exibe o conteúdo do arquivo
print(df)

✨ O código faz o seguinte:

1. Importa o pandas.
2. Usa pd.read_csv() para ler o arquivo chamado listagem.csv.
3. Guarda os dados no DataFrame df.
4. Imprime todo o conteúdo do arquivo.

💡 Assim, você consegue transformar seu CSV em uma tabela bem estruturada para manipulação dentro do Python.

Varrendo os registros de um CSV.

Depois de carregar o CSV no Pandas, você pode percorrer os registros linha a linha usando o método iterrows(). Assim, cada linha é lida como um índice e uma série de dados.

📌 Aqui está a continuação do programa:

import pandas as pd

# Lê o arquivo CSV
df = pd.read_csv("listagem.csv")

# Exibe todo o conteúdo do arquivo
print("Conteúdo completo do arquivo:\n")
print(df)

print("\nVarredura linha a linha:\n")
# Percorre cada linha do DataFrame
for index, row in df.iterrows():
    print(f"Linha {index}: {row.to_dict()}")

---

✨ O que esse código faz:

1. Lê o listagem.csv no DataFrame df.
2. Mostra o conteúdo completo.
3. Varre linha por linha do DataFrame.
4. Para cada linha, imprime um dicionário com os nomes das colunas e os valores.

📌 Exemplo de saída (supondo o CSV com nome,idade,cidade):

Linha 0: {'nome': 'Maria', 'idade': 25, 'cidade': 'São Paulo'}
Linha 1: {'nome': 'João', 'idade': 30, 'cidade': 'Rio de Janeiro'}
Linha 2: {'nome': 'Ana', 'idade': 22, 'cidade': 'Belo Horizonte'}

---

Quer que eu prepare uma versão onde, ao invés de imprimir o dicionário inteiro, já traga cada campo formatadinho, tipo:
👉 Maria - 25 anos - São Paulo?

Verificando informações com PANDAS

Podemos deixar o programa interativo: ele pergunta ao usuário uma faixa de idade (mínimo e máximo) e depois filtra as pessoas do listagem.csv que estão dentro desse intervalo.

Aqui está o código:

import pandas as pd

# Lê o arquivo CSV
df = pd.read_csv("listagem.csv")

# Pergunta ao usuário a faixa de idade
idade_min = int(input("Digite a idade mínima: "))
idade_max = int(input("Digite a idade máxima: "))

# Filtra os registros que estão na faixa
resultado = df[(df['idade'] >= idade_min) & (df['idade'] <= idade_max)]

# Mostra o resultado
print("\nPessoas dentro da faixa etária escolhida:\n")
if resultado.empty:
    print("Nenhuma pessoa encontrada nessa faixa de idade.")
else:
    for index, row in resultado.iterrows():
        print(f"{row['nome']} - {row['idade']} anos - {row['cidade']}")

✨ O que acontece aqui:

1. Lê o CSV no DataFrame.
2. Pede ao usuário a idade mínima e máxima.
3. Usa um filtro lógico para selecionar apenas quem está entre os dois valores.
4. Mostra o resultado de forma organizada.

📌 Exemplo de saída:

Digite a idade mínima: 20
Digite a idade máxima: 25

Pessoas dentro da faixa etária escolhida:

Maria - 25 anos - São Paulo
Ana - 22 anos - Belo Horizonte

Outras funcionalidades do pandas

O Pandas é super poderoso e tem muitas funcionalidades além de só ler e filtrar CSV. Vou te mostrar algumas das mais usadas com exemplos práticos:

---

📌 1. Mostrar só algumas linhas

print(df.head())   # primeiras 5 linhas
print(df.tail())   # últimas 5 linhas

---

📌 2. Ver informações rápidas do DataFrame

print(df.info())     # mostra colunas, tipos e nulos
print(df.describe()) # estatísticas (média, desvio, min, max, etc.)

---

📌 3. Selecionar colunas específicas

print(df['nome'])          # apenas a coluna "nome"
print(df[['nome', 'idade']])  # duas colunas

---

📌 4. Filtrar com condições

# Pessoas acima de 25 anos
print(df[df['idade'] > 25])

# Pessoas da cidade "São Paulo"
print(df[df['cidade'] == "São Paulo"])

---

📌 5. Ordenar registros

print(df.sort_values(by="idade"))              # do mais novo para o mais velho
print(df.sort_values(by="idade", ascending=False))  # do mais velho para o mais novo

---

📌 6. Agrupar dados

# Média de idade por cidade
print(df.groupby("cidade")["idade"].mean())

---

📌 7. Contar ocorrências

# Quantas pessoas por cidade
print(df["cidade"].value_counts())

---

📌 8. Criar ou modificar colunas

# Criar coluna com idade em meses
df["idade_meses"] = df["idade"] * 12
print(df)

---

📌 9. Exportar resultados

# Salvar em outro CSV
df.to_csv("resultado.csv", index=False)

---

✨ Ou seja, o Pandas serve não só para ler arquivos CSV, mas também para explorar, analisar e transformar dados de forma rápida e prática.

Buscar dados e analise dos dados.

Existem locais que se pode buscar dados abertos, em geral. O governo fornece diversas bases de dados para que seja utilizada por alunos e profissionais a fim de analise de dados.

https://arquivos.receitafederal.gov.br/dados/cnpj/dados_abertos_cnpj/2025-08

Se olharmos estes dados podemos verificar o cnae de diversos produtos.

0111301″;”Cultivo de arroz”
“0111302”;”Cultivo de milho”
“0111303”;”Cultivo de trigo”
“0111399”;”Cultivo de outros cereais não especificados anteriormente”
“0112101”;”Cultivo de algodão herbáceo”
“0112102”;”Cultivo de juta”
“0112199”;”Cultivo de outras fibras de lavoura temporária não especificadas anteriormente”
“0113000”;”Cultivo de cana-de-açúcar”
“0114800”;”Cultivo de fumo”
“0115600”;”Cultivo de soja”
“0116401”;”Cultivo de amendoim”
“0116402”;”Cultivo de girassol”
“0116403”;”Cultivo de mamona”
“0116499”;”Cultivo de outras oleaginosas de lavoura temporária não especificadas anteriormente”
“0119901”;”Cultivo de abacaxi”
“0119902”;”Cultivo de alho”
“0119903”;”Cultivo de batata-inglesa”
“0119904”;”Cultivo de cebola”
“0119905”;”Cultivo de feijão”

O CNAE significa Classificação Nacional de Atividades Econômicas.

📌 Ele é um padrão oficial no Brasil criado pelo IBGE e utilizado pela Receita Federal, juntas comerciais, prefeituras e outros órgãos para identificar e categorizar a atividade econômica de empresas e profissionais.

✨ Principais pontos:

• Cada atividade econômica tem um código numérico único (exemplo: comércio de roupas, consultoria em TI, fabricação de móveis etc.).
• É usado em cadastros fiscais (como o CNPJ) e em registros de empresas.
• Serve para padronizar estatísticas e informações econômicas em nível nacional.
• Impacta diretamente em tributos e enquadramento fiscal (pois a atividade define impostos e obrigações).

---

📌 Exemplo de código CNAE:

• 62.01-5/01 → Desenvolvimento de programas de computador sob encomenda.
• 47.54-7/01 → Comércio varejista de móveis.

---

Ou seja, o CNAE funciona como um RG da atividade da empresa, identificando exatamente o que ela faz.

Tarefa.

Buscar atividades relacionadas que contem a palavra açaí.

Desenvolva um programa que pega a lista de CNAI e dado uma palavra busca todos os que tiverem aquela palavra.

Trabalho de Programação em Python

Objetivo do trabalho:

O objetivo deste trabalho é criar um arquivo para impressão 3D.

Visão sobre o projeto e informações sobre o ambiente

🟦 O que é CNC?

✨ CNC significa Controle Numérico Computadorizado (Computer Numerical Control).

• É a automação de máquinas (fresadoras, tornos, impressoras 3D, cortadoras a laser, etc.).
• No lugar de um operador manual girando manivelas, o computador controla os motores.
• O programa informa onde a ferramenta deve ir, a velocidade e o que fazer.

➡️ Resultado: peças produzidas com mais precisão, repetibilidade e velocidade.

Exemplos de máquinas CNC:

• Fresadora CNC (corta metal ou madeira).
• Torno CNC (peças cilíndricas).
• Impressora 3D (constrói objetos em camadas).
• Router CNC (corte em madeira e acrílico).
• Laser CNC (gravação/corte de chapas).

---

🟦 O que é G-code?

✨ O G-code é a linguagem usada pelas máquinas CNC.

Cada linha é uma instrução que a máquina entende.

É formado por códigos de duas letras (como G1, M104) seguidos de números (coordenadas, temperaturas, velocidades).

🟦 Como nasce uma peça CNC

1. O engenheiro desenha em CAD (3D).
2. O software CAM (fatiador, slicer, etc.) gera o G-code.
3. O G-code é enviado para a máquina CNC.
4. A máquina executa linha a linha e cria a peça.

---

🟦 Por que é importante aprender?

• O CNC está presente em indústria, medicina, aeronáutica, prototipagem e design.
• Entender G-code é como entender a “gramática” das máquinas.
• Mesmo que existam softwares automáticos, saber G-code permite:
  • Ajustar peças.
  • Corrigir erros.
  • Criar trajetórias personalizadas.

Qual o GCode da Ender-3

O padrão de G-code da Ender-3 é o Marlin/RepRap flavor, não FANUC, Mitsubishi ou Siemens. Eles são todos “G-code”, mas os dialetos são diferentes.

🔹 Diferença principal:

• A Ender-3 segue o padrão Marlin/RepRap (open-source) → voltado para impressoras 3D, bem simplificado.
• Já os CNC industriais (FANUC, Mitsubishi, Siemens) usam dialetos diferentes de ISO G-code, com foco em fresadoras, tornos e centros de usinagem, que possuem muitos recursos que uma impressora 3D não precisa (offsets, ciclos fixos, compensações de ferramenta, etc).

📌 Comparativo resumido:

Sistema	Padrão/Dialeto G-code	Usado em
Ender-3	Marlin/RepRap (G0, G1, G28, M104…)	Impressoras 3D
FANUC	ISO G-code (muitos ciclos fixos, G71, G81, etc)	CNC industrial (torno/fresa)
Mitsubishi	Próprio dialeto ISO compatível, similar ao FANUC	CNC industrial
Siemens	Sinumerik (ISO G-code, mas com macros próprios e ciclos especiais)	CNC industrial

Comandos GCode básico.

🟦 Configuração inicial

• G21 → Define as unidades em milímetros (a Ender-3 trabalha sempre em mm).
• G90 → Define o modo absoluto de posicionamento (as coordenadas X/Y/Z são relativas ao 0,0 da mesa).
• M82 → Define a extrusão em modo absoluto (valores de E sempre crescem).
• G28 → Faz o homing de todos os eixos (leva X, Y e Z até os switches de fim de curso).

---

🟦 Aquecimento (opcional)

• M104 S200 → Seta a temperatura do bico em 200 °C, mas não espera aquecer.
• M140 S60 → Seta a temperatura da mesa em 60 °C, mas também não espera.
• M109 S200 → Define o bico em 200 °C e espera até atingir antes de continuar.
• M190 S60 → Define a mesa em 60 °C e espera até atingir.

(Esses eu deixei comentados, caso queira imprimir de fato, não só movimentar.)

---

🟦 Movimentação inicial

• G1 Z0.20 F1200 → Move o bico para a altura de 0.20 mm acima da mesa, na velocidade de 1200 mm/min.
• G1 X110 Y110 F6000 → Leva o bico até o centro da mesa (coordenada X110 Y110), rápido.
• G1 X130 Y110 F3000 → Move até a posição inicial do círculo (20 mm à direita do centro).

---

🟦 Configuração de extrusão

• M83 → Define a extrusão como relativa (cada valor de E representa apenas o incremento de filamento).
• G92 E0 → Zera o contador de extrusão (dizendo ao firmware que estamos em E=0).
• G1 F1200 → Define a velocidade padrão (feedrate) de 1200 mm/min para os próximos movimentos.

---

🟦 Desenhando o círculo

• G2 → Faz um movimento circular horário (clockwise).
• X... Y... → Define o ponto final do arco.
• I... J... → Define o centro do arco em relação ao ponto inicial.
• E... → Quantidade de filamento extrudido durante o arco.

No código:

1. G2 X90 Y110 I-20 J0 E2.10 → Desenha meia-volta (da direita pro lado esquerdo do círculo), extrudindo 2.1 mm de filamento.
2. G2 X130 Y110 I20 J0 E2.10 → Fecha a volta (do lado esquerdo de volta à direita), extrudindo mais 2.1 mm.

---

🟦 Finalização

• G1 Z5 F3000 → Levanta o bico 5 mm para não arranhar a peça.
• M84 → Desliga os motores (desenergiza os steppers).

Exemplo de Código na Ender-3

; ===== Círculo Ender-3 (Marlin/RepRap) =====
; Raio: 20 mm | Centro: X110 Y110 | Camada: 0.20 mm | Largura: 0.40 mm
; Filamento: 1.75 mm | Extrusão total aprox: 4.20 mm

G21                 ; mm
G90                 ; coordenadas absolutas
M82                 ; extrusão absoluta por padrão
G28                 ; home X Y Z

; (opcional) aquecer
; M104 S200         ; bico 200°C
; M140 S60          ; mesa 60°C
; M109 S200         ; aguarda bico
; M190 S60          ; aguarda mesa

G1 Z0.20 F1200      ; altura de primeira camada (ajuste se quiser)
G1 X110 Y110 F6000  ; vai ao centro da mesa
G1 X130 Y110 F3000  ; vai ao ponto inicial do círculo (raio 20 mm à direita)

M83                 ; extrusão relativa
G92 E0              ; zera extrusor
G1 F1200            ; feed para impressão

; Círculo completo em duas meias-voltas (G2 = horário)
; Meia-volta 1: de (130,110) até (90,110) com centro em (110,110) => I=-20 J=0
G2 X90  Y110 I-20 J0 E2.10

; Meia-volta 2: de (90,110) até (130,110) com centro em (110,110) => I=+20 J=0
G2 X130 Y110 I20  J0 E2.10

; fim
G1 Z5 F3000         ; levanta
M84                 ; desativa motores
; ============================================

Visualizando o arquivo

O usuário pode verificar o arquivo, copiando o mesmo para o site:

https://ncviewer.com

Click em Novo arquivo, e copie o fonte

Neste exemplo criamos apenas uma camada. Onde incluímos e verificamos o desenho.

Agora iremos mostrar como fica o gcode com multiplas camadas.

; ===== Ender-3 | Cilindro oco (raio 10mm, altura 5mm, camada 0.20mm) =====
; Centro: X110 Y110 | Bico: 0.4 | Parede ≈ 0.8 mm (2 voltas por camada)
; Material sugerido: PLA (200/60). Ajuste se necessário.

G21                 ; mm
G90                 ; posicoes absolutas em X/Y/Z
M82                 ; extrusao absoluta por padrao
G28                 ; homing

; --- Aquecimento (descomente para imprimir de verdade) ---
; M104 S200          ; bico 200°C (nao espera)
; M140 S60           ; mesa 60°C (nao espera)
; M109 S200          ; bico 200°C (espera)
; M190 S60           ; mesa 60°C (espera)

G0 Z0.20 F1200      ; primeira camada
G0 X110 Y110 F6000  ; vai ao centro da mesa
G0 X120 Y110 F6000  ; ponto inicial do circulo (raio 10 mm para a direita)

M83                 ; extrusao relativa (E incrementa por trecho)
G92 E0              ; zera extrusor
G1 F1200            ; feed de impressao (~20 mm/s)

; Observacao: cada meia-volta extrude ~1.05 mm (estimado p/ bico 0.4, camada 0.2)

; ---------------------- Camada 1 (Z=0.20) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z0.40 F1200

; ---------------------- Camada 2 (Z=0.40) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z0.60 F1200

; ---------------------- Camada 3 (Z=0.60) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z0.80 F1200

; ---------------------- Camada 4 (Z=0.80) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z1.00 F1200

; ---------------------- Camada 5 (Z=1.00) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z1.20 F1200

; ---------------------- Camada 6 (Z=1.20) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z1.40 F1200

; ---------------------- Camada 7 (Z=1.40) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z1.60 F1200

; ---------------------- Camada 8 (Z=1.60) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z1.80 F1200

; ---------------------- Camada 9 (Z=1.80) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z2.00 F1200

; ---------------------- Camada 10 (Z=2.00) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z2.20 F1200

; ---------------------- Camada 11 (Z=2.20) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z2.40 F1200

; ---------------------- Camada 12 (Z=2.40) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z2.60 F1200

; ---------------------- Camada 13 (Z=2.60) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z2.80 F1200

; ---------------------- Camada 14 (Z=2.80) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z3.00 F1200

; ---------------------- Camada 15 (Z=3.00) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z3.20 F1200

; ---------------------- Camada 16 (Z=3.20) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z3.40 F1200

; ---------------------- Camada 17 (Z=3.40) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z3.60 F1200

; ---------------------- Camada 18 (Z=3.60) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z3.80 F1200

; ---------------------- Camada 19 (Z=3.80) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z4.00 F1200

; ---------------------- Camada 20 (Z=4.00) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z4.20 F1200

; ---------------------- Camada 21 (Z=4.20) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z4.40 F1200

; ---------------------- Camada 22 (Z=4.40) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z4.60 F1200

; ---------------------- Camada 23 (Z=4.60) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z4.80 F1200

; ---------------------- Camada 24 (Z=4.80) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z5.00 F1200

; ---------------------- Camada 25 (Z=5.00) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05

; --- Finalizacao ---
G1 Z10 F3000        ; afasta o bico
; M104 S0           ; desligar bico (descomente se aqueceu)
; M140 S0           ; desligar mesa (descomente se aqueceu)
M84                 ; motores off
; =================================================================

O arquivo pode ser baixado aqui.

Como fica o arquivo pronto.

Base do Python

📘 Como criar e gravar um arquivo com Python

Em Python, para criar um arquivo de texto usamos a função open().

• O primeiro parâmetro é o nome do arquivo (ex.: "cilindro.gcode").
• O segundo parâmetro é o modo de abertura:
  • "w" → escrever (se já existir, sobrescreve).
  • "a" → acrescentar no final (append).
  • "r" → apenas leitura.

Depois usamos o método .write() para gravar conteúdo no arquivo.
No final, usamos .close() (ou o with que fecha automaticamente).

# Criar e gravar um arquivo de texto em Python

# Abre (ou cria) o arquivo chamado "cilindro.gcode" no modo escrita ("w")
with open("cilindro.gcode", "w", encoding="utf-8") as arquivo:
    # Grava apenas uma linha de texto no arquivo
    arquivo.write("G21 ; usar milimetros\n")

print("Arquivo 'cilindro.gcode' criado com sucesso!")

🔹 O que acontece aqui?

1. O Python cria um novo arquivo chamado cilindro.gcode na pasta onde o script está rodando.
2. Escreve dentro dele a linha: G21 ; usar milimetros
3. Fecha o arquivo automaticamente (porque usamos with).
4. Agora esse arquivo pode ser aberto em qualquer editor de texto.

Criando o programa em python com 10 camadas.

# -*- coding: utf-8 -*-
# Gera G-code para um cilindro (tubo) com 10 camadas – Ender-3 / Marlin
# Saída: cilindro_10camadas.gcode

import math

# ===== Parâmetros =====
RAIO_MM       = 10.0         # raio do cilindro (mm)
CAMADAS       = 10           # quantidade de camadas solicitada
ALTURA_CAM_MM = 0.20         # espessura da camada (mm) → 10 camadas = 2,0 mm
CENTRO_X      = 110.0        # centro aproximado da Ender-3
CENTRO_Y      = 110.0
LARG_LINHA    = 0.40         # ~bico 0.4
VEL_IMPR      = 1200         # mm/min (~20 mm/s)
VEL_VIAGEM    = 6000         # mm/min
SEGMENTOS     = 120          # segmentos para aproximar o círculo

# Extrusão (E relativo) – modelo simples
FILAMENTO_D   = 1.75
AREA_FILA     = math.pi * (FILAMENTO_D/2.0)**2  # mm²

def e_para_trecho(compr_mm: float) -> float:
    """Converte o comprimento do trecho em mm do filamento a extrudar (E)."""
    volume = LARG_LINHA * ALTURA_CAM_MM * compr_mm   # mm³
    return volume / AREA_FILA                        # mm de filamento

def anel_g1(z: float, raio: float, nseg: int) -> list[str]:
    """Retorna linhas G-code (G1) aproximando um círculo com 'nseg' segmentos."""
    linhas = []
    # vai ao ponto inicial (ângulo 0) sem extrudar
    x0 = CENTRO_X + raio
    y0 = CENTRO_Y
    linhas.append(f"G0 X{x0:.3f} Y{y0:.3f} Z{z:.3f} F{VEL_VIAGEM}")

    ang_step = 2 * math.pi / nseg
    x_prev, y_prev = x0, y0
    for i in range(1, nseg + 1):
        ang = i * ang_step
        x = CENTRO_X + raio * math.cos(ang)
        y = CENTRO_Y + raio * math.sin(ang)
        L = math.hypot(x - x_prev, y - y_prev)
        e = e_para_trecho(L)
        linhas.append(f"G1 X{x:.3f} Y{y:.3f} E{e:.5f} F{VEL_IMPR}")
        x_prev, y_prev = x, y

    return linhas

# ===== Montagem do G-code =====
g = []
g.append("; ===== Ender-3 | Cilindro (tubo) – 10 camadas =====")
g.append(f"; Raio={RAIO_MM} mm | Camadas={CAMADAS} | h={ALTURA_CAM_MM} mm | centro=({CENTRO_X},{CENTRO_Y})")
g.append("G21            ; mm")
g.append("G90            ; posicoes absolutas")
g.append("M82            ; extrusao absoluta (padrão)")
g.append("G28            ; homing")
# Aquecimento opcional – descomente se for imprimir de verdade
#g.append("M104 S200      ; bico 200C (nao espera)")
#g.append("M140 S60       ; mesa 60C (nao espera)")
#g.append("M109 S200      ; bico 200C (espera)")
#g.append("M190 S60       ; mesa 60C (espera)")

g.append("G0 Z0.20 F1200 ; primeira camada")
g.append(f"G0 X{CENTRO_X:.3f} Y{CENTRO_Y:.3f} F{VEL_VIAGEM}")
g.append(f"G0 X{CENTRO_X+RAIO_MM:.3f} Y{CENTRO_Y:.3f} F{VEL_VIAGEM}")
g.append("M83            ; extrusao relativa")
g.append("G92 E0         ; zera extrusor")
z = ALTURA_CAM_MM

for camada in range(1, CAMADAS + 1):
    g.append(f"; --- Camada {camada}/{CAMADAS} (Z={z:.2f}) ---")
    g.extend(anel_g1(z, RAIO_MM, SEGMENTOS))
    if camada < CAMADAS:
        z += ALTURA_CAM_MM
        g.append(f"G0 Z{z:.3f} F{VEL_VIAGEM}")

# Finalização
g.append("G0 Z10 F3000   ; afasta a peça")
#g.append("M104 S0        ; desliga bico (se aqueceu)")
#g.append("M140 S0        ; desliga mesa (se aqueceu)")
g.append("M84            ; motores off")
g.append("; ================================================")

with open("cilindro_10camadas.gcode", "w", encoding="utf-8") as f:
    f.write("\n".join(g))

print("OK: arquivo gerado 'cilindro_10camadas.gcode'")

🔹 Conclusão

✅ Pontos positivos do que foi apresentado

• Você aprendeu que o G-code é apenas um arquivo texto, criado em qualquer editor ou até gerado automaticamente com Python.
• Vimos como montar um cilindro simples na Ender-3: cada camada é um círculo (ou anel) e, ao empilhar, formamos a peça 3D.
• O exercício mostrou que é possível entender a lógica por trás dos slicers (Cura, PrusaSlicer), ou seja, como os softwares de fatiamento transformam o modelo 3D em comandos de máquina.
• A integração com Python abriu espaço para automatizar a criação de trajetórias, o que pode ser aplicado tanto no ensino quanto em projetos reais.

---

🔧 O que pode ser melhorado no código

• Hoje usamos uma aproximação simples da extrusão. Podemos melhorar:
  • Calibrando melhor a relação entre comprimento da linha e extrusão (considerando fluxo real da impressora).
  • Adicionando duas ou mais paredes e infill (preenchimento interno) para criar cilindros sólidos.
  • Gerando movimentos de skirt/brim (bordas externas) para melhorar a aderência na mesa.
  • Inserindo parâmetros configuráveis como temperaturas, velocidades, e altura de camada em variáveis globais.
• Outra evolução seria criar uma função para gerar qualquer geometria básica (quadrados, triângulos, espirais) — ótimo como exercício de programação para alunos.

---

🏭 Como as empresas usam essa técnica em projetos avançados

• Na indústria 4.0, G-code é usado em usinagem CNC (torno, fresadora, router) para fabricar peças metálicas e plásticas com altíssima precisão.
• Em empresas de impressão 3D, o código é gerado automaticamente por slicers avançados, mas muitos engenheiros ainda ajustam o G-code manualmente para:
  • Criar estruturas de suporte inteligentes.
  • Controlar velocidades diferentes por região da peça.
  • Inserir pausas programadas (para troca de cor, inserir peças metálicas, sensores, etc).
• Em projetos mais complexos, o G-code pode ser integrado com simulações digitais (digital twins), verificando antes se a trajetória da ferramenta será eficiente, segura e otimizada.
• Grandes empresas usam até G-code adaptativo: a máquina lê sensores em tempo real (vibração, temperatura, pressão) e ajusta o código dinamicamente, algo que está evoluindo em direção à manufatura inteligente e autônoma.

---

👉 Ou seja, o que fizemos aqui — gerar um cilindro simples em Python — é uma porta de entrada para entender como máquinas e softwares conversam.
O conceito de criar e manipular arquivos de texto está presente em praticamente toda a computação:

• Impressão 3D e CNC → geração de arquivos G-code.
• Programação → arquivos usados por compiladores (código-fonte em C, Java, Python).
• Escritório → planilhas eletrônicas (CSV, XLSX), processadores de texto (DOCX, ODT, RTF) e apresentações (PPTX) são, na essência, arquivos de texto ou estruturados.
• Web → arquivos HTML, CSS e JSON, que formam sites e APIs.
• Banco de dados → exportação de informações em CSV, SQL scripts.
• Ciência de dados → geração automática de relatórios, datasets em TXT/CSV para análise.
• Automação → scripts Python criam logs de sistemas, arquivos de configuração e até relatórios prontos em PDF.

Assim, usar Python para construir e manipular arquivos não se limita ao G-code: abre uma gama enorme de aplicações, como:

• Criar relatórios automáticos de uma pesquisa.
• Gerar gráficos e salvar em arquivos para apresentação.
• Simular experimentos e salvar resultados em planilhas.
• Desenvolver conversores (por exemplo, transformar dados em XML, JSON ou YAML).
• Automatizar tarefas repetitivas em empresas, economizando tempo e reduzindo erros.

Esse mesmo raciocínio — simples, mas poderoso — é o que sustenta desde projetos escolares até sistemas industriais complexos, permitindo que a programação conecte ideias a resultados práticos no mundo real.

Este blog foi gerado com auxilio do CHATGPT 5.

Será utilizado em treinamento no curso técnico da Escola Estadual Diva Tarlá, em Ribeirão Preto.

🔬💡 Projeto/Prática: Como um Sistema Computacional Pode Resolver Problemas de Eletrônica – O Cálculo da Resistência de um LED Usando Python

🔋💡 História: A Lâmpada Misteriosa de Lucas

Lucas tem 16 anos, é curioso e adora desmontar coisas. Um dia, enquanto mexia numa caixa de sucata do avô, encontrou uma pequena lâmpada de LED vermelha e uma bateria de 9V.

— “Será que consigo acender isso?”, pensou, empolgado.

Ele conectou o LED direto na bateria. Por um instante, ele brilhou forte… e depois queimou!

— “Mas por que isso aconteceu? Não era só ligar e pronto?”

Frustrado, Lucas correu até sua irmã Ana, que estava estudando para a prova de física. Ela olhou para ele e sorriu:

— Ana: “Lucas, você acabou de aprender na prática o que eu estudei hoje: Lei de Ohm e eletricidade básica.”

---

🔌 Capítulo 1 – A Descoberta da Eletricidade

Ana pegou um papel e começou a desenhar:

— Ana: “Lembra que a gente aprendeu que a eletricidade é o movimento dos elétrons?
Na escola, estudamos tensão (voltagem), que é como a pressão da água num cano, e corrente, que é como o fluxo dessa água. E tem também a resistência, que é como se fosse um aperto no cano que controla o fluxo.”

Lucas, curioso, respondeu:
— Lucas: “Ah, então quando liguei o LED direto na bateria, era como jogar um jato de água sem controle?”

— Ana: “Exatamente! O LED não aguenta toda essa ‘pressão’. É por isso que ele queimou.”

---

📐 Capítulo 2 – A Lei de Ohm

Ana escreveu a fórmula da Lei de Ohm no caderno: V=R⋅IV = R \cdot IV=R⋅I

— Ana: “Olha só: se reorganizarmos, podemos calcular a resistência necessária:” R=Vfonte−VLEDILEDR = \frac{V_\text{fonte} – V_\text{LED}}{I_\text{LED}}R=ILED​Vfonte​−VLED​​

Lucas ficou intrigado.
— Lucas: “Então preciso de um resistor para proteger o LED?”

— Ana: “Sim! Isso é exatamente o que aprendemos em física: controlar a corrente usando resistência.”

Ela explicou que cada cor de LED tem uma queda de tensão típica. Pegou uma tabela na internet:

Cor do LED	Tensão típica (V)
🔴 Vermelho	2,0 V
🟢 Verde	2,2 V
🔵 Azul	3,0 V
⚪ Branco	3,2 V

---

💻 Capítulo 3 – O Computador como Ferramenta

Lucas, empolgado, disse:
— Lucas: “Mas calcular isso toda hora é chato. Vou programar isso!”

Ele abriu o notebook e escreveu em Python:

def calcular_resistencia(v_fonte, v_led, i_led_mA):
    """
    Calcula a resistência ideal para um LED usando a Lei de Ohm.
    v_fonte: tensão da fonte (Volts)
    v_led: tensão típica do LED (Volts)
    i_led_mA: corrente do LED (miliamperes)
    """
    i_led = i_led_mA / 1000  # converte mA para A
    return (v_fonte - v_led) / i_led

print("=== Sistema Computacional: Cálculo de Resistor para LED ===")
v_fonte = float(input("Digite a tensão da fonte (V): "))
v_led = float(input("Digite a tensão do LED (V): "))
i_led_mA = float(input("Digite a corrente do LED (mA): "))

resistor = calcular_resistencia(v_fonte, v_led, i_led_mA)
print(f"\n🔧 Resistor recomendado: {resistor:.2f} Ω")
print("Use o valor comercial mais próximo.")

Ele digitou os valores:

• Fonte: 9V
• LED vermelho: 2V
• Corrente: 20mA

O computador respondeu:

Resistor recomendado: 350.00 Ω

Lucas ficou maravilhado:
— Lucas: “Então com um resistor de 350Ω, meu LED vai funcionar sem queimar?”

— Ana: “Sim! E olha como você aplicou física e programação juntas. Isso é exatamente o que estamos aprendendo no segundo grau: usar conceitos teóricos para resolver problemas práticos.”

---

🔬 Capítulo 4 – A Experiência Prática

No dia seguinte, Lucas levou o circuito para a escola. Na aula de física, a professora pediu que os alunos montassem o mesmo experimento em protoboards.

Eles testaram resistores diferentes:

• Com 330Ω: LED brilhante, seguro.
• Com 1kΩ: LED fraco, mas protegido.
• Sem resistor: queimou na hora.

A turma riu quando viram o LED queimando sem resistor, e todos compreenderam de forma prática o motivo da existência dos resistores.

---

🎓 Conclusão da História

Ao final da aula, a professora disse:

“O que Lucas fez foi criar um sistema computacional para resolver um problema real de eletrônica. Ele aplicou conceitos de física (Lei de Ohm), eletrônica (uso de resistores) e programação (Python) de forma integrada.”

Lucas sorriu. Agora, sempre que via um LED acender — seja na TV, no celular ou até no semáforo — ele lembrava que havia ciência e cálculo por trás daquele simples pontinho de luz.

---

🧩 Plano Prático para Aplicação

Inspirado na história de Lucas, você fará o mesmo em sala de aula:

1. Revisar física básica: tensão, corrente e resistência.
2. Aprender a Lei de Ohm: com exemplos simples e analogias.
3. Programar em Python: criar o cálculo automático do resistor.
4. Montar o circuito: usar LED, bateria e resistores em protoboard.
5. Testar valores diferentes: ver o LED acender, ficar fraco ou queimar.
6. Discutir resultados: refletir sobre como ciência e tecnologia se complementam.

Vamos a prática

🔧 Multímetro

O multímetro é uma ferramenta essencial para medir e testar circuitos elétricos. Ele será usado no projeto para:

• Medir a tensão da fonte (V): verificar se a bateria ou fonte realmente fornece 9V (ou o valor configurado).
• Medir a resistência do resistor (Ω): confirmar se o resistor utilizado tem o valor correto, conforme a tabela de cores.
• Verificar continuidade: testar se as ligações na protoboard estão corretas e sem falhas.

📌 Aplicação no projeto: Antes de ligar o LED, os alunos vão usar o multímetro para conferir a voltagem da fonte e o valor do resistor escolhido. Isso evita erros e garante segurança.

---

🔌 Protoboard

A protoboard será o espaço para montar e testar o circuito do LED sem necessidade de solda.

• Permite inserir a bateria, resistor e LED facilmente.
• Possui trilhas internas conectadas que facilitam a montagem e modificação rápida do circuito.
• Ideal para experimentação, como trocar resistores e observar o efeito no brilho do LED.

📌 Aplicação no projeto: Os alunos irão montar o circuito calculado (Fonte → Resistor → LED) na protoboard e testar os diferentes valores de resistência.

---

🎨 Tabela de Cores dos Resistores

Os resistores têm faixas coloridas que indicam seu valor em Ohms. Essa tabela será usada para identificar e confirmar os resistores corretos para o projeto.

Cor	Número
Preto	0
Marrom	1
Vermelho	2
Laranja	3
Amarelo	4
Verde	5
Azul	6
Violeta	7
Cinza	8
Branco	9

• Duas primeiras cores: dígitos do valor.
• Terceira cor: multiplicador.
• Quarta cor: tolerância (ex.: dourado = ±5%).

📌 Aplicação no projeto: Após calcular o valor com Python, os alunos vão:

1. Consultar a tabela de cores para escolher o resistor adequado.
2. Conferir com o multímetro se o valor está correto.
3. Montar na protoboard e observar o LED funcionando.

---

🔬 Fluxo Prático no Projeto

1️⃣ Calcular no Python o valor do resistor.
2️⃣ Identificar o resistor pela tabela de cores.
3️⃣ Medir no multímetro para confirmar o valor.
4️⃣ Montar o circuito na protoboard com a fonte, resistor e LED.
5️⃣ Ligar e observar: testar brilho e segurança do LED.
6️⃣ Experimentar resistores de valores diferentes e anotar os resultados.

---

🧪 Apresentação da Prática: Cálculo e Montagem de Circuito com LED e Resistor

🎯 Objetivo da Prática

• Compreender na prática a relação entre tensão, corrente e resistência usando a Lei de Ohm.
• Utilizar Python para calcular o resistor ideal para um LED.
• Aprender a identificar resistores pela tabela de cores e confirmar seu valor com um multímetro.
• Montar um circuito real em uma protoboard e testar seu funcionamento.

---

🗂 Etapas da Apresentação

🔹 1. Introdução Teórica (15 min)

Objetivo: Relembrar conceitos fundamentais e contextualizar o experimento.

• Início lúdico: Mostrar imagens de LEDs em objetos do dia a dia (TVs, semáforos, celulares).
• Explicar rapidamente os conceitos de tensão (voltagem), corrente elétrica e resistência, usando a analogia da água em um cano:
  • Tensão = pressão da água.
  • Corrente = fluxo da água.
  • Resistência = estreitamento no cano que limita o fluxo.
• Introduzir a Lei de Ohm e sua fórmula: V=R⋅I⇒R=Vfonte−VLEDILEDV = R \cdot I \quad \Rightarrow \quad R = \frac{V_\text{fonte} – V_\text{LED}}{I_\text{LED}}V=R⋅I⇒R=ILED​Vfonte​−VLED​​
• Mostrar a tabela de tensões dos LEDs (diferentes cores, diferentes tensões).

---

🔹 2. Demonstração de Ferramentas (15 min)

Objetivo: Familiarizar os alunos com os instrumentos e componentes.

• Protoboard: Mostrar como é a distribuição interna de trilhas (linhas horizontais e verticais).
• Multímetro:
  • Demonstrar como medir tensão da fonte (modo Volts DC).
  • Demonstrar como medir resistência de resistores (modo Ohms).
• Tabela de cores de resistores:
  • Explicar como identificar resistores com base nas faixas coloridas.
  • Exemplo prático: um resistor vermelho-violeta-marrom-dourado é 270Ω ±5%.

---

🔹 3. Programação do Cálculo (20 min)

Objetivo: Aplicar programação para automatizar o cálculo do resistor.

• Apresentar o código Python para cálculo do resistor.
• No computador ou Google Colab, pedir para os alunos executarem:
  • Fonte: 9V
  • LED: Vermelho (2V)
  • Corrente: 20mA
• O programa retorna: 350Ω.
• Discutir sobre o resistor comercial mais próximo (330Ω).

---

🔹 4. Identificação e Teste do Resistor (15 min)

Objetivo: Relacionar cálculo teórico com identificação prática.

• Cada grupo escolhe um resistor conforme o cálculo.
• Usar a tabela de cores para identificar o valor correspondente.
• Confirmar com o multímetro se o valor bate com o esperado.

---

🔹 5. Montagem na Protoboard (20 min)

Objetivo: Aplicar física e programação para criar o circuito.

• Montar o circuito:
  • Fonte (bateria de 9V ou fonte de bancada).
  • Resistor calculado.
  • LED conectado na posição correta (anodo e catodo).
• Conferir as conexões com o multímetro (continuidade).
• Ligar o circuito e observar o LED acendendo.

---

🔹 6. Testes Experimentais (20 min)

Objetivo: Observar efeitos práticos de diferentes resistências.

• Trocar o resistor por valores diferentes:
  • Menor valor: LED mais brilhante (risco de queimar).
  • Maior valor: LED mais fraco, mas protegido.
  • Sem resistor: LED queimando (feito com um LED de demonstração pelo professor).
• Discutir o efeito de cada mudança e como a resistência controla a corrente.

---

🔹 7. Encerramento e Discussão (15 min)

Objetivo: Consolidar os conceitos.

• Revisar:
  • Como a Lei de Ohm foi aplicada.
  • Como o Python ajudou no cálculo automático.
  • O uso do multímetro para validar componentes.
  • A importância da protoboard para testes seguros.
• Relacionar com situações do cotidiano (fontes de energia, carregadores de celular, luzes LED em carros).
• Convidar os alunos a criar novos cálculos e testar LEDs de diferentes cores.

---

🧩 Materiais Necessários

• Protoboard.
• LEDs de diferentes cores.
• Resistores variados.
• Fonte de alimentação (bateria 9V ou fonte regulada).
• Multímetros digitais (um por grupo).
• Computador ou celular com Python (Google Colab).
• Tabela de cores de resistores impressa.

---

🔬 Resultados Esperados

• Compreensão clara de como calcular e testar resistores.
• Capacidade de usar ferramentas práticas como multímetro e protoboard.
• Entender a integração entre física teórica e aplicação prática.
• Visualizar como programação ajuda a resolver problemas reais de eletrônica.

Exercícios comentados

1️⃣ Exercício: Gerenciamento de Mudanças em Requisitos

Enunciado

Uma clínica médica está implementando um sistema de prontuário eletrônico. Durante o desenvolvimento, um novo requisito surge: permitir que os pacientes consultem seus exames online.

Tarefas:

1. Elaborar um plano de gerenciamento de mudanças.
2. Criar um fluxo UML para análise/aprovação da mudança.
3. Explicar como métodos ágeis poderiam ajudar.

---

Resolução

Plano de Gerenciamento de Mudanças:

• Identificação da Mudança: Inclusão do módulo de consulta de exames online.
• Justificativa: Aumentar a autonomia dos pacientes e reduzir demanda no atendimento.
• Avaliação de Impacto:
  • Custo: Necessidade de servidor seguro e integração com o laboratório.
  • Prazo: Estimativa de +3 sprints no Scrum.
  • Segurança: Implementação de autenticação multifator.
  • Usabilidade: Interface simplificada para acesso via celular.
• Prioridade: Alta (impacto direto no valor para o cliente).
• Controle de Versão: Atualização do documento de requisitos (IEEE 830).

Fluxo UML (atividade simplificada):

[Solicitação de Mudança] → [Análise de Impacto] → [Aprovação do Comitê] → 
[Planejamento no Backlog] → [Implementação e Testes] → [Deploy e Feedback]

Métodos Ágeis:

• Scrum permite ajustes rápidos via backlog.
• Cada sprint incorpora incrementos pequenos (entrega contínua).
• Feedback dos usuários nas revisões ajuda a validar rapidamente.

---

2️⃣ Exercício: Herança e Encapsulamento

Enunciado

Crie uma classe Pessoa com atributos comuns (nome, idade e CPF), e duas subclasses: Aluno e Professor, que herdam atributos e adicionam informações específicas.

---

Resolução em Python

class Pessoa:
    def __init__(self, nome, idade, cpf):
        self._nome = nome
        self._idade = idade
        self._cpf = cpf

    def get_nome(self):
        return self._nome

    def set_nome(self, nome):
        self._nome = nome

    def get_idade(self):
        return self._idade

    def set_idade(self, idade):
        self._idade = idade

    def get_cpf(self):
        return self._cpf

    def set_cpf(self, cpf):
        self._cpf = cpf


class Aluno(Pessoa):
    def __init__(self, nome, idade, cpf, serie):
        super().__init__(nome, idade, cpf)
        self.serie = serie

    def exibir_informacoes(self):
        return f"Aluno: {self.get_nome()}, Idade: {self.get_idade()}, Série: {self.serie}"


class Professor(Pessoa):
    def __init__(self, nome, idade, cpf, disciplina):
        super().__init__(nome, idade, cpf)
        self.disciplina = disciplina

    def exibir_informacoes(self):
        return f"Professor: {self.get_nome()}, Idade: {self.get_idade()}, Disciplina: {self.disciplina}"


# Teste
aluno1 = Aluno("Carlos", 15, "123.456.789-00", "9º Ano")
prof1 = Professor("Ana", 35, "987.654.321-00", "Matemática")

print(aluno1.exibir_informacoes())
print(prof1.exibir_informacoes())

Saída esperada:

yamlCopiarEditarAluno: Carlos, Idade: 15, Série: 9º Ano
Professor: Ana, Idade: 35, Disciplina: Matemática

---

3️⃣ Exercício: Polimorfismo em um Sistema de Entregas

Enunciado

Implemente classes de transporte (Moto, Caminhao, Drone) que calculam o tempo de entrega de forma distinta, utilizando polimorfismo.

---

Resolução em Python

from abc import ABC, abstractmethod

class Transporte(ABC):
    @abstractmethod
    def calcular_tempo(self, distancia):
        pass


class Moto(Transporte):
    def calcular_tempo(self, distancia):
        velocidade = 60  # km/h
        return distancia / velocidade


class Caminhao(Transporte):
    def calcular_tempo(self, distancia):
        velocidade = 40  # km/h
        return distancia / velocidade


class Drone(Transporte):
    def calcular_tempo(self, distancia):
        velocidade = 80  # km/h
        return distancia / velocidade


# Teste com polimorfismo
transportes = [Moto(), Caminhao(), Drone()]
distancia = 120  # km

for t in transportes:
    print(f"{t.__class__.__name__}: Tempo estimado = {t.calcular_tempo(distancia):.2f} horas")

Saída esperada:

Moto: Tempo estimado = 2.00 horas
Caminhao: Tempo estimado = 3.00 horas
Drone: Tempo estimado = 1.50 horas

Programação – 3 Bimestre

Validação e Verificação de Requisitos

• Verificação de requisitos: Processo que assegura clareza, completude, consistência, rastreabilidade e testabilidade antes do desenvolvimento.
  • Técnicas: revisões por pares, análise de gap, checklists, matriz de rastreabilidade e critérios de aceitação.
  • Ferramentas: IBM Rational DOORS, JIRA e Enterprise Architect.
• Validação de requisitos: Garante que o sistema atenda às necessidades dos stakeholders, evitando mal-entendidos e retrabalho.
  • Ferramentas: planilhas de validação, reuniões com clientes, critérios claros de aceitação e feedback contínuo.
  • Exemplo: uso em sistemas de e-commerce, finanças pessoais e reservas de voos.

---

Pilares da Programação Orientada a Objetos (POO) – Encapsulamento

• Conceito: Protege atributos e métodos de uma classe, permitindo acesso controlado através de getters e setters.
• Benefícios:
  • Segurança: impede alterações indevidas nos dados.
  • Manutenibilidade: facilita ajustes e ampliações no código.
  • Modularidade: separa responsabilidades, tornando o sistema mais organizado.
• Exemplos práticos em Python:
  • Controle de curtidas em e-commerce.
  • Sistema de gestão de carros com atributos encapsulados.
  • Sistema de biblioteca com implementação de métodos de acesso.

---

Principais Aprendizados

1. Requisitos bem validados e verificados reduzem falhas e retrabalho no desenvolvimento.
2. POO com encapsulamento reforça boas práticas de segurança e organização no código.
3. Ferramentas de apoio (planilhas, checklists, IDEs) otimizam processos técnicos e colaborativos.
4. Exemplos reais facilitam a compreensão e aplicação dos conceitos de engenharia de software.

Encapsulamento em Projetos Práticos (POO)

• Reforço do encapsulamento: Controle de atributos e métodos com segurança e acesso controlado, melhorando integridade e confiabilidade do código.
• Exemplo prático: Sistema de controle de estoque de carros, com classes Carro e Estoque, aplicação de getters e setters, e métodos como adicionar_carro.
• Benefícios: Segurança, manutenção facilitada, modularidade e prevenção de bugs.
• Questões éticas: Proteção de dados, segurança cibernética e transparência no uso de informações.

---

Testes Não Funcionais

• Desenvolvimento e execução: Identificação de requisitos não funcionais (desempenho, segurança, usabilidade, confiabilidade), definição de critérios e uso de ferramentas apropriadas.
• Ferramentas e práticas:
  • Pentest: Exploração de vulnerabilidades usando Kali Linux e ferramentas como SQLMap e PortSwigger.
  • Burp Suite: Interceptação e modificação de requisições HTTP para identificar falhas de controle de acesso.
• Testes de desempenho e segurança: Avaliação de escalabilidade, estabilidade, vulnerabilidades e usabilidade.
• OWASP Top 10: Referência essencial para práticas de segurança web.

---

Diagramas UML – Diagrama de Estados

• Definição: Representa mudanças de estados de um objeto ou sistema em resposta a eventos.
• Elementos principais:
  • Estados (inicial, intermediários e final).
  • Transições acionadas por eventos.
  • Ações associadas às mudanças de estado.
• Exemplos práticos:
  • Controle de acesso eletrônico (porta: fechada, abrindo, aberta, fechando, trancada).
  • Processo de matrícula em instituições educacionais.
• Benefícios: Visualização do comportamento do sistema, identificação de falhas e melhor comunicação entre stakeholders.

Diagramas UML – Atividades

• Definição: Ferramenta visual que modela o fluxo de atividades, ações e decisões em sistemas e processos.
• Aplicações:
  • Modelagem de processos de negócios (reservas de passagens aéreas).
  • Desenvolvimento de software (fluxos de tela, módulos específicos).
  • Engenharia de sistemas complexos (controle de tráfego aéreo).
• Benefícios:
  • Facilita comunicação entre stakeholders.
  • Identifica gargalos e otimiza processos.
  • Documenta sistemas e facilita manutenção.
• Ferramentas: Lucidchart, Draw.io, Microsoft Visio.

---

Herança em POO

• Conceito: Permite que classes herdem atributos e métodos de outras, criando hierarquias reutilizáveis.
• Exemplo prático:
  • ContaBancaria (superclasse): métodos comuns (depositar, sacar, consultar_saldo).
  • ContaCorrente, ContaPoupanca e ContaInvestimento (subclasses) com funcionalidades específicas.
• Reutilização de código:
  • Implementação de cálculos de tarifas com métodos estáticos e classes utilitárias.
  • Inclusão de novas funcionalidades (ex: conta universitária gratuita) sem duplicação de código.
• Método de transferência: Transferência entre contas com verificação de saldo.
• Aspectos éticos:
  • Privacidade dos dados, segurança de transações e transparência nas práticas bancárias.

---

Principais Aprendizados

1. Diagramas de atividades ajudam na visualização, comunicação e melhoria de sistemas.
2. Herança simplifica manutenção e amplia escalabilidade, evitando duplicação de código.
3. Práticas éticas e segurança devem ser consideradas na implementação de sistemas financeiros.
4. Ferramentas de modelagem e POO combinadas fornecem base sólida para projetos de software.

Gerenciamento de Mudanças em Requisitos

• Definição: Processo contínuo que ocorre durante todo o ciclo de vida do projeto, envolvendo identificação, análise, documentação, priorização e controle de requisitos.
• Importância:
  • Permite adaptação às mudanças de mercado e necessidades do cliente.
  • Minimiza riscos e falhas decorrentes de requisitos mal gerenciados.
• Boas práticas:
  • Documentação clara e enxuta.
  • Avaliação de impacto (prazo, custo e qualidade).
  • Controle rigoroso de versões e rastreabilidade.
• Exemplos práticos: Aplicação em sistemas de saúde (SUS), lojas e softwares corporativos, com foco em segurança e ética (proteção de dados).

---

Herança em Projetos Práticos (POO)

• Exemplo aplicado: Sistema de gestão de loja de eletrônicos.
  • Classe base: ProdutoEletronico (atributos e métodos comuns).
  • Subclasses: Smartphone, Laptop, Televisor, cada uma com características próprias.
• Benefícios da herança:
  • Reutilização de código.
  • Estrutura hierárquica clara e extensível.
  • Facilidade de manutenção e escalabilidade.
• Prática de implementação:
  • Testes práticos para validar métodos.
  • Flexibilidade para novos tipos de produtos.

---

Principais Aprendizados

1. Gerenciamento eficaz de requisitos é essencial para evitar falhas e alinhar o projeto às expectativas do cliente.
2. Documentação ágil e enxuta facilita comunicação e evita burocracia excessiva.
3. Herança em POO permite criar sistemas organizados, reutilizáveis e preparados para expansão.
4. Aspectos éticos e segurança devem ser considerados tanto no gerenciamento de mudanças quanto na implementação de software.

Herança em Projetos Práticos

• Exemplo aplicado: Sistema de gerenciamento escolar com classes Pessoa, Funcionario e Aluno, mostrando a criação de estruturas hierárquicas e reutilização de código.
• Conceitos aplicados:
  • Encapsulamento de atributos e métodos.
  • Uso de composição (objetos como atributos de outras classes).
  • Estrutura hierárquica clara e extensível para novos tipos de entidades.

---

Polimorfismo (POO)

• Definição: Permite que objetos de diferentes classes respondam de forma distinta a uma mesma interface, aumentando flexibilidade e reutilização.
• Tipos abordados:
  • Sobreposição (override): Subclasses redefinem métodos herdados da classe pai.
  • Exemplo prático: Sistema de entregas com veículos (carro, caminhão, bicicleta), cada um com cálculo específico de tempo de entrega.
• Aplicações adicionais:
  • Loja virtual com diferentes tipos de produtos (livros, eletrônicos e alimentos).
  • Sistema de rastreamento de encomendas com classes Encomenda, Pacote, Carta e RemessaGrande, utilizando herança e sobreposição para especializações.

---

Benefícios Chave

1. Reutilização de código: Com herança e polimorfismo, métodos comuns são centralizados e especializados conforme necessário.
2. Flexibilidade e extensibilidade: Fácil adição de novos tipos de classes sem alterar estruturas existentes.
3. Modelagem próxima ao mundo real: Representação clara de entidades e suas relações hierárquicas.
4. Manutenção simplificada: Alterações localizadas reduzem riscos de falhas globais no sistema.