0

Sumário
Semana 1 .................................................................................................................................2
Pensamento Computacional .................................................................................................. 2
Evolução da computação e paradigmas de programação ..................................................... 4
Semana 2 .................................................................................................................................7
Introdução ao Google Colab para implementação em Python e Ciência de Dados ............... 7
Jupyter Notebook e Projeto Jupyter na Computação Interativa ............................................ 7
Google Colab como Ambiente de Desenvolvimento e suas Vantagens ................................. 8
Criando Variáveis............................................................................................................. 8
Exibindo Variáveis ........................................................................................................... 8
Manipulando Variáveis .................................................................................................... 8
Criando uma Função ....................................................................................................... 9
Chamando uma Função................................................................................................... 9
Criando uma Lista ............................................................................................................ 9
Adicionando Itens à Lista................................................................................................. 9
Acessando e Modificando Itens ...................................................................................... 9
Criando um Dicionário................................................................................................... 10
Acessando Valores por Chave: ...................................................................................... 10
Adicionando e Modificando Pares Chave-Valor ............................................................ 10
Utilizando a Biblioteca Pandas ...................................................................................... 11
Carregando Dados a partir de um CSV .......................................................................... 11
Calculando a Média e a Mediana .................................................................................. 11
Criando Gráficos com a Função plot() ........................................................................... 11
Semana 3 ...............................................................................................................................12
Projeto de Desenvolvimento de Software, Algoritmo e Implementação............................. 12
Projetos de Desenvolvimento: ............................................................................................. 13
Gerência no desenvolvimento de software: ........................................................................ 14
Semana 4 - Padrões importantes da Web, HTML, JSON e Python ..........................................14
Histórico e Padrões clássicos da Web, HTML5, CSS3, JSon .................................................. 14
Bibliotecas e Frameworks .................................................................................................... 15
Semana 5 - Framework Python, APIs e Web Services.............................................................18
Framework Phyton .............................................................................................................. 18
APIs e Web Services ............................................................................................................. 19
Semana 6 -Internet das Coisas (IoT) e os protocolos MQTT e REST ........................................20
Internet das Coisas (loT) ...................................................................................................... 20
MQTT e REST ....................................................................................................................... 21
Semana 7 ...............................................................................................................................23
Ciência de Dados ................................................................................................................. 23
Ciência de Dados e Python .................................................................................................. 23

1
Semana 1

Pensamento Computacional

Entre as várias definições de pensamento computacional, podemos dizer que ele é a

“capacidade de sistematizar, representar, analisar e resolver problemas” conforme as diretrizes
para o ensino de Computação na Educação Básica - SBC. O pensamento computacional não se
limita aos contextos que envolvem diretamente as ciências da computação, ele também é
aplicado para descrever, explicar e modelar processos complexos no universo em diversas áreas
do conhecimento.

As definições são variadas, segundo Jeannette Wing “Pensamento Computacional é uma

habilidade fundamental para todos, não somente para os cientistas da computação”. Ela
também afirma que o pensamento computacional compreende “os processos de pensamento
envolvidos na formulação de um problema e que expressam sua solução ou soluções
eficazmente, de tal forma que uma máquina ou uma pessoa possa realizar”.

Sendo uma abordagem sistemática (organizada de acordo com uma certa ordem, com critérios).
O pensamento computacional funciona identificando um problema e o decompondo em
elementos menores, que são analisados individualmente, focando apenas em detalhes
importantes e assim criar soluções. Podemos dizer que ele se baseia em quatro pilares que
orientam o processo de solução de problemas:

Decomposição: é o processo que divide os problemas em partes menores para facilitar a

resolução, desenvolvimento e gerenciamento. Analisa os problemas para identificar as partes
que podem ser separadas e formas como podem ser reconstituídas para solucionar um
problema como um todo. Possibilita resolver problemas complexos de forma mais simples e
permite projetar sistemas de grande porte.

Reconhecimento de padrões: os padrões são similaridades ou características que alguns

problemas compartilham. O hábito de identificar padrões nos acompanha desde a infância, é
uma construção continuada e o nosso repertório de padrões não para de crescer e de se
reconstruir. O processo de reconhecimento de padrões permite encontrar similaridades ou
padrões entre pequenos problemas decompostos. Quanto mais padrões encontrarmos, mais
fácil e rápida será a nossa tarefa geral de solução de problemas.

Abstração: consiste na filtragem a classificação dos dados, criando mecanismos que permitam
separar apenas os elementos essenciais em determinado problema, ignorando detalhes
irrelevantes. Permite criar uma representação, uma ideia do que está se tentando resolver.
Neste processo, essencial é escolher o detalhe a ser ignorado para que o problema seja mais
fácil de ser compreendido sem perder nenhuma informação que seja importante para tal.

Algoritmo: é uma sequência finita de etapas (passos), cada qual executável em um tempo finito,
por um agente computacional, natural (humano) ou sintético (computador). Um algoritmo é um
plano, uma estratégia ou um conjunto de instruções ordenadas para a solução de um problema
ou execução de uma tarefa. A formulação de um algoritmo passa pelo processo de
decomposição, reconhecimento de padrões e abstração. Na execução seguirão os passos pré-
definidos, não havendo a necessidade de criar um novo algoritmo para cada uma de suas
execuções posteriores. É o pilar que agrega os demais pilares.

2
Por fim, é importante pontuar as contribuições que o pensamento computacional traz para o
indivíduo:

● Pensamento Algorítmico: Capacidade de projetar e seguir sequências lógicas de

passos para resolver problemas, levando a soluções estruturadas e eficientes.

● Aprendizagem Colaborativa: Estimula o trabalho em equipe, permitindo que várias

mentes contribuam para a solução de problemas complexos.

● Resolução de Problemas: Fomenta uma abordagem sistemática para enfrentar

desafios, identificando padrões e aplicando estratégias adequadas.

● Criatividade: O pensamento computacional incentiva a busca por soluções inovadoras

e criativas, ampliando a capacidade de encontrar alternativas únicas.

● Raciocínio Lógico: Desenvolve habilidades para análise e argumentação coerente,

essenciais para tomar decisões informadas e sustentadas.

● Interpretação Textual: Ajuda na compreensão e análise de informações escritas,

permitindo que as pessoas sejam mais críticas e reflexivas ao ler e interpretar textos.

Seu grau de importância pode ser comprovado de muitas formas, uma delas é observando as
dez habilidades essenciais do profissional do futuro segundo o Fórum Econômico Mundial:

1. Resolução de problemas complexos

2. Pensamento crítico

3. Criatividade

4. Gestão de pessoas

5. Coordenação

6. Inteligência Emocional

7. Capacidade de julgamento e de tomada de decisões

8. Orientação para servir

9. Negociação

10. Flexibilidade cognitiva

Por fim, o estudo do pensamento computacional é importante para o mercado de trabalho, uma
vez que:

1. Programar desenvolve habilidades de pensamento.

2. Programação é essencial como alfabetização digital.

3. Aborda diversas disciplinas simultaneamente.

4. Capacita para resolver problemas de forma sistemática.

5. Fomenta persistência e superação de desafios.

3
6. Estimula a criatividade e a inovação.

7. É acessível a todos, possibilitando aprendizado para todos.

Evolução da computação e paradigmas de programação

Os computadores como conhecemos hoje possuem um interessante histórico de evolução:

Década de 60: Mainframes - Os computadores eram grandes e caros, geralmente encontrados

em centros de processamento de dados de grandes empresas e instituições governamentais.
Eles processavam dados em lotes e forneciam suporte para várias tarefas comerciais e
científicas.

Década de 80: Redes de microcomputadores e emuladores - A popularização dos

microcomputadores permitiu a descentralização do poder de processamento. As redes de
computadores começaram a surgir, conectando vários microcomputadores para compartilhar
informações e recursos. Os emuladores permitiam que computadores de diferentes
arquiteturas pudessem executar softwares de outras plataformas.

Década de 90: Cliente-Servidor - Com o avanço das redes de computadores, o modelo cliente-
servidor se tornou predominante. Os computadores clientes acessavam e interagiam com
servidores que forneciam serviços e recursos. Isso permitiu uma melhor distribuição do
processamento e facilitou o compartilhamento de informações em ambientes empresariais.

Atualidade: Internet 2.0, Redes Sociais, IoT - A internet evoluiu para uma nova fase, conhecida
como Internet 2.0 ou Web 2.0. Nesse cenário, os usuários não apenas consomem conteúdo, mas
também contribuem e interagem ativamente na criação de conteúdo, por meio de redes sociais
e plataformas colaborativas. Além disso, a Internet das Coisas (IoT) tornou-se uma realidade,
conectando dispositivos e objetos do cotidiano à rede, permitindo a coleta e o
compartilhamento de dados em tempo real. Essas tecnologias estão transformando a maneira
como vivemos, trabalhamos e nos comunicamos.

Na atualidade, nos anos 2000, ocorreu uma grande explosão da web, impulsionada pela
facilidade de aquisição de computadores e pelo acesso à internet para o público em geral. A
tecnologia avançou rapidamente, resultando em significativos avanços em diversas áreas. A
popularização da internet permitiu que as pessoas se conectassem globalmente,
compartilhando informações e conhecimentos de forma sem precedentes. A disseminação de
dispositivos móveis e smartphones impulsionou a mobilidade e a conectividade constante.

Além disso, houve avanços significativos em áreas como inteligência artificial, big data,
computação em nuvem e Internet das Coisas (IoT), transformando a maneira como vivemos,
trabalhamos e nos comunicamos. A atualidade é marcada por uma crescente integração da
tecnologia em todos os aspectos da vida moderna, proporcionando oportunidades e desafios
únicos em nossa sociedade globalizada e digital.

A evolução da internet ao longo dos anos tem sido notável e transformadora. Desde a era da
internet discada, passando pela expansão da banda larga e a criação das redes móveis 3G, 4G e
5G, a conectividade se tornou mais rápida, estável e abrangente. Atualmente, a internet é
essencial no cotidiano, tanto para empresas quanto para residências, sendo uma ferramenta
indispensável para comunicação, trabalho, educação, entretenimento e muito mais.

4
A internet agora permeia diversos objetos e lugares por meio da Internet das Coisas (IoT), que
conecta dispositivos inteligentes à rede, permitindo a troca de dados e automação de processos.
A IoT abriu caminho para inúmeras aplicações inovadoras, como casas inteligentes, cidades
inteligentes, dispositivos vestíveis, sistemas de monitoramento e muito mais.

As linguagens de programação são ferramentas que permitem a comunicação entre os

programadores e o computador. Elas são compostas por um conjunto de comandos que, quando
utilizados corretamente, instruem o computador a executar ações específicas. Cada linguagem
pode seguir um paradigma de programação, que é uma abordagem ou estilo particular para
resolver problemas.

Existem diferentes paradigmas de programação, como o paradigma imperativo, orientado a

objetos, funcional, entre outros. Um paradigma pode ser entendido como um “Meio de se
classificar as linguagens de programação baseado em suas funcionalidades”. Cada paradigma
oferece uma maneira única de estruturar e organizar o código, permitindo abordar diferentes
tipos de problemas de forma mais eficiente e legível.

As linguagens de programação são uma parte essencial da tecnologia da informação e são

usadas para desenvolver uma ampla variedade de software, desde aplicativos móveis e sistemas
web até programas para controle industrial e análise de dados. Cada linguagem tem suas
características distintas e é mais adequada para determinadas tarefas, sendo escolhida com
base nas necessidades e objetivos específicos do projeto em questão.

Existem dois principais paradigmas de programação: o paradigma imperativo e o paradigma

declarativo.

Paradigma Imperativo:

● Procedural: Nesse paradigma, os programas são escritos em forma de procedimentos

ou funções, que contêm um conjunto de instruções sequenciais que são executadas
passo a passo. A execução do programa segue uma sequência explícita de comandos.

● Estrutura de Blocos: É uma extensão do paradigma procedural que organiza o código

em blocos de código isolados, permitindo melhor organização e reutilização de código.

● Orientação a Objetos: Nesse paradigma, os programas são estruturados em torno de

objetos, que representam entidades do mundo real. Os objetos têm atributos e
comportamentos, e a interação entre eles é realizada por meio de métodos e
mensagens.

● Computação Distribuída: Esse paradigma envolve a programação de sistemas

distribuídos, nos quais diferentes componentes de software são executados em várias
máquinas conectadas em rede. Os programas são projetados para funcionar em
ambientes distribuídos e colaborativos.

Paradigma Declarativo:

● Funcional: Nesse paradigma, o foco está em descrever o que o programa deve fazer, em
vez de como fazer. Os programas são construídos a partir de funções matemáticas
puras, que não têm efeitos colaterais e não alteram o estado do programa. Isso permite
uma programação mais concisa e fácil de entender.

5
 ● Programação Lógica: Nesse paradigma, os programas são baseados na lógica formal e
na resolução de problemas por meio de inferências lógicas. As relações lógicas são
especificadas e o sistema de inferência deduz soluções para os problemas com base
nessas relações.

A estrutura de tipos em linguagens de programação refere-se à forma como os tipos de dados

são tratados e verificados em relação às operações realizadas no código. Existem quatro
principais classificações de estrutura de tipos:

● Fracamente tipada (Weakly Typed): Em linguagens fracamente tipadas, as conversões

automáticas entre diferentes tipos de dados são realizadas implicitamente, sem a
necessidade de intervenção explícita do programador. Isso pode levar a resultados
inesperados e potenciais erros, pois as operações podem ser executadas entre tipos de
dados diferentes sem verificações rigorosas. Exemplo: PHP, JavaScript.
● Fortemente tipada (Strongly Typed): Em linguagens fortemente tipadas, as conversões
entre tipos de dados devem ser explicitamente especificadas pelo programador. As
operações entre tipos incompatíveis resultarão em erros ou precisam ser tratadas de
maneira explícita pelo desenvolvedor. Isso garante mais segurança e previsibilidade no
código. Exemplo: C++, Java, Python.
● Dinamicamente tipada (Dynamically Typed): Em linguagens dinamicamente tipadas, o
tipo de uma variável é determinado em tempo de execução, ou seja, durante a execução
do programa. As variáveis podem mudar de tipo ao longo do código, e não é necessário
declarar o tipo de uma variável antecipadamente. Exemplo: Python, JavaScript.
● Estaticamente tipada (Statically Typed): Em linguagens estaticamente tipadas, o tipo de
uma variável é verificado em tempo de compilação, ou seja, antes da execução do
programa. As variáveis devem ter seu tipo declarado explicitamente no momento da
criação, e as operações entre tipos incompatíveis são detectadas durante a compilação,
evitando erros no código em tempo de execução. Exemplo: C++, Java.

Os TRADE-OFFs, ou trocas compensatórias, são situações em que dois ou mais critérios ou

objetivos conflitantes precisam ser equilibrados para tomar uma decisão. No contexto de
linguagens de programação, um exemplo de TRADE-OFF é o equilíbrio entre confiabilidade e
custo de execução.

No exemplo citado, a linguagem Java optou por priorizar a confiabilidade ao exigir que todas as
referências aos elementos de um vetor sejam verificadas para garantir que os índices estejam
dentro de suas faixas válidas. Isso aumenta o custo de execução dos programas, principalmente
quando há um grande número de referências a elementos de vetores. No entanto, essa
verificação adicional melhora a confiabilidade do código, evitando erros de acesso a elementos
fora dos limites do vetor, o que poderia causar comportamento indefinido ou falhas no
programa.

Essa decisão de TRADE-OFF é comum em muitos projetos de linguagens de programação e

software em geral. Os desenvolvedores precisam ponderar os prós e contras de diferentes
abordagens para encontrar um equilíbrio adequado entre os objetivos conflitantes. No caso de
Java, a escolha foi favorecer a confiabilidade, mesmo que isso resulte em uma diminuição na
eficiência de execução em alguns casos.

Essas trocas são inevitáveis e podem ser necessárias para atender aos requisitos do projeto e às
expectativas dos usuários. Cada decisão envolve uma análise cuidadosa dos requisitos e das
implicações para encontrar a melhor solução possível, considerando todos os fatores relevantes.

6
Aprender linguagens de programação de diferentes categorias é benéfico por várias razões:

● Aumenta nossa capacidade de programar: Aprender diferentes construções e

paradigmas de programação amplia nosso conjunto de ferramentas para resolver
problemas de maneiras diversas e eficientes.

● Escolher linguagens adequadas para projetos: Com um conhecimento diversificado,

podemos selecionar a linguagem mais adequada para cada projeto, considerando
requisitos, desempenho e facilidade de desenvolvimento.

● Facilita o aprendizado de novas linguagens: Com experiência em várias linguagens, é

mais fácil aprender outras, pois muitos conceitos e princípios são compartilhados entre
elas.

Ao projetar e avaliar linguagens de programação, é crucial considerar o domínio em que a

linguagem será aplicada. Diferentes linguagens são mais adequadas para diferentes tarefas e
áreas de aplicação.

Além disso, critérios como legibilidade, facilidade de escrita, confiabilidade e custo são cruciais
na avaliação das linguagens. Uma linguagem de programação deve ser legível e fácil de entender
para facilitar a manutenção do código. A facilidade de escrita é importante para acelerar o
desenvolvimento de software. A confiabilidade é fundamental para evitar erros e garantir a
estabilidade dos programas. Por fim, o custo, que inclui recursos de hardware e tempo de
desenvolvimento, é um fator crítico na escolha de uma linguagem para um projeto específico.

Semana 2

Introdução ao Google Colab para implementação em Python e Ciência de Dados

A geração de soluções através da programação envolve a criação de algoritmos, que são

sequências de instruções lógicas para resolver problemas específicos. Linguagens de
programação como Python fornecem uma sintaxe clara e legível, permitindo que os
programadores expressem conceitos complexos de maneira eficiente. Python é conhecida por
sua legibilidade e simplicidade, favorecendo o desenvolvimento rápido e facilitando a
colaboração. É uma das linguagens mais populares para desenvolvimento web, científico e de
aprendizado de máquina. Ambientes de desenvolvimento, como editores de código e
Integrated Development Environments (IDEs), aprimoram a experiência de programação,
oferecendo recursos como realce de sintaxe, depuração e gerenciamento de projetos.

Jupyter Notebook e Projeto Jupyter na Computação Interativa

O Jupyter Notebook é uma aplicação web que permite criar e compartilhar documentos
interativos contendo códigos, visualizações e texto. Ele é um componente do Projeto Jupyter,
uma iniciativa que visa facilitar a computação interativa e a criação de conteúdo científico.
Notebooks Jupyter promovem a exploração de dados e experimentação de algoritmos,
tornando o processo de desenvolvimento mais iterativo e colaborativo.

7
Google Colab como Ambiente de Desenvolvimento e suas Vantagens

O Google Colab estende os benefícios dos notebooks Jupyter ao oferecer um ambiente de

desenvolvimento integrado baseado na nuvem. Ele elimina a necessidade de configuração de
ambiente, permitindo que os desenvolvedores executem código Python diretamente no
navegador, aproveitando recursos de hardware, como CPUs e GPUs. Além disso, o Colab
permite a colaboração em tempo real, facilitando o compartilhamento e a edição conjunta de
projetos.

No Google Colab, os códigos são organizados em células, permitindo a execução isolada e

iterativa de partes específicas. Essa abordagem facilita a depuração e a experimentação. Além
disso, o Colab oferece acesso gratuito a GPUs, que aceleram o processamento de tarefas
intensivas, como treinamento de modelos de aprendizado de máquina. O compartilhamento
de notebooks é simples, permitindo que outros visualizem, executem e façam modificações
nos projetos.

Criando Variáveis
No Google Colab, você pode criar variáveis simplesmente digitando o nome da variável seguido
por um sinal de igual e o valor que você deseja atribuir a ela.

Exibindo Variáveis
Para exibir o valor de uma variável no Colab, basta digitar o nome da variável em uma célula e
executá-la.

Após digitar o nome da variável e pressionar Shift + Enter, você verá o valor da variável idade
exibido abaixo da célula.

Manipulando Variáveis
Você pode realizar operações matemáticas e manipular variáveis da mesma forma que faria no
Python. Para nomear funções e variáveis de forma clara, é adotado o padrão Snake case, em
que as palavras são separadas por sublinhados. Isso melhora a legibilidade do código e facilita a
compreensão das partes envolvidas.

Agora, é possível calcular o ano de nascimento subtraindo a idade do ano atual:

8
E exibir o resultado:

Criando uma Função

As funções utilizam a sintaxe básica do Python. Aqui está um exemplo de uma função simples
que soma dois números:

Chamando uma Função

Após criar a função, é possível chamá-la em uma célula de código posterior. Digitando o nome
da função seguido por parênteses contendo os argumentos.

Criando uma Lista

Adicionando Itens à Lista

Utilizando o método append() é possível adicionar itens um por um. Por exemplo:

Acessando e Modificando Itens

É possível acessar os itens da lista pelo seu índice, começando do índice 0. Por exemplo:

Para modificar um item, basta atribuir um novo valor a um índice específico:

9
Criando um Dicionário
Os dicionários são estruturas de dados fundamentais em Python que permitem armazenar
pares chave-valor. Cada chave é única e mapeada a um valor correspondente. Neste exemplo,
vamos explorar como criar, acessar e manipular dicionários no Google Colab.

Cada par chave-valor é definido entre chaves {} e separado por dois pontos “:”.

Acessando Valores por Chave:

É possível acessar os valores de um dicionário fornecendo a chave correspondente. Por
exemplo:

Adicionando e Modificando Pares Chave-Valor

Novos pares chave-valor podem ser acrescentados ao dicionário utilizando o seguinte método.

E para modificar um valor existente:

Utilizando a Biblioteca Pandas

A biblioteca Pandas é uma das ferramentas mais populares e poderosas do ecossistema
Python quando se trata de análise de dados e manipulação de tabelas. Ela fornece estruturas

10
de dados e funções para trabalhar com dados de maneira eficiente e flexível. O nome "Pandas"
é derivado da expressão "Panel Data" (dados em painel), que se refere a dados
multidimensionais, comuns em análise estatística e econômica.

Carregando Dados a partir de um CSV

Imagine que haja um arquivo CSV com informações sobre valores numéricos que precisam ser
analisados. A função pd.read_csv() pode ser empregada para carregar esses dados em um
DataFrame da seguinte forma:

Calculando a Média e a Mediana

Com dados no DataFrame é possível calcular a média e a mediana dos valores usando os
métodos mean() e median() do DataFrame:

Criando Gráficos com a Função plot()

A biblioteca Pandas possui recursos integrados para criar gráficos facilmente, como a função
plot(). Segue a baixo alguns exemplos.

11
Semana 3

Projeto de Desenvolvimento de Software, Algoritmo e Implementação

Na literatura voltada para a gestão de projetos, destaca-se o PMBOK, cuja sigla significa "Project
Management Body of Knowledge" (Corpo de Conhecimento em Gerenciamento de Projetos). O
PMBOK é um guia de referência para as melhores práticas em gerenciamento de projetos.
Embora não seja um método de gerenciamento de projetos em si, ele reúne um conjunto
consolidado de conhecimentos que descreve processos, práticas, conceitos e terminologias
amplamente aceitos no campo do gerenciamento de projetos. Essas diretrizes são publicadas e
mantidas pelo Project Management Institute (PMI), uma organização profissional dedicada ao
avanço e desenvolvimento da disciplina de gerenciamento de projetos.

12
De maneira similar ao PMBOK, porém com foco no gerenciamento de projetos relacionados à
engenharia de software, temos o SWEBOK (Software Engineering Body of Knowledge), um
compêndio de conhecimentos, práticas, processos e conceitos amplamente reconhecidos e
aceitos na disciplina de engenharia de software. O objetivo do SWEBOK é estabelecer as bases
para o campo da engenharia de software, definindo os princípios fundamentais que os
profissionais devem compreender e aplicar em seu trabalho. Isso contribui para o
aprimoramento da qualidade e eficácia das práticas de engenharia de software, promovendo
um padrão elevado de excelência na indústria. Tanto o PMBOK quanto o SWEBOK server como
balizadores para o conteúdo abordados nas aulas dessa semana.

Projetos de Desenvolvimento:

Um projeto, conforme descrito no PMBOK, é um esforço temporário que visa alcançar um

resultado único dentro de recursos limitados. Para garantir o sucesso do projeto, é crucial um
planejamento adequado, a definição de datas, alocação de recursos, determinação do escopo e
a avaliação dos custos. Esses princípios são refletidos nas fases de desenvolvimento de software,
onde a definição clara dos objetivos, requisitos e restrições é fundamental para um progresso
ordenado e controlado.

Os projetos de software apresentam características únicas que demandam abordagens

especializadas. A temporalidade é essencial, uma vez que os projetos possuem início e fim
definidos. A importância das pessoas ressalta a necessidade de equipes qualificadas e
colaborativas. O escopo é crucial para estabelecer limites e evitar o "escopo creep", que ocorre
quando o escopo cresce em tamanho e complexidade durante a execução do projeto. Portanto
o planejamento é vital para uma execução eficiente e bem-sucedida. Esses elementos são
fundamentais para o processo de desenvolvimento de software e estão incorporados nos
modelos de processo e abordagens ágeis.

Estimar recursos em projetos de software é desafiador devido à complexidade e à natureza

criativa do desenvolvimento. A experiência e o histórico de projetos semelhantes desempenham
um papel importante na realização de estimativas precisas. Princípios de estimativa, como a
análise de pontos de função, são abordados para auxiliar na projeção de cronogramas e
orçamentos realistas. Levar em consideração as incertezas e adaptar-se às mudanças, como
sugerido pelas abordagens ágeis, são elementos críticos para lidar com a natureza evolutiva dos
projetos de software.

Ao comparar o desenvolvimento de software com outras disciplinas de engenharia, torna-se

evidente a necessidade de processos organizados e sistematizados para lidar com a
complexidade inerente. Assim como em outras engenharias, a engenharia de software envolve
a aplicação de métodos e técnicas bem definidos para atingir objetivos específicos. A abordagem
sistemática é crucial para garantir qualidade, previsibilidade e eficiência na criação de software,
independentemente de sua natureza inovadora.

A escolha de modelos de processo, como o modelo em cascata, modelo espiral ou abordagens

ágeis como o Scrum, depende das características do projeto e dos requisitos do cliente. A
importância das fases, como definição, desenvolvimento e manutenção, destaca a necessidade
de um planejamento cuidadoso para garantir a entrega bem-sucedida do software. A aplicação

13
desses processos é essencial para criar produtos de software de alta qualidade e satisfazer o
cliente.

Gerência no desenvolvimento de software:

A gerência desempenha um papel vital no desenvolvimento de software, fornecendo a estrutura

para o planejamento, monitoramento e controle de projetos. As decisões tomadas pela gerência
têm impacto direto na qualidade, progresso e sucesso do projeto. Liderança eficaz, comunicação
clara e tomada de decisões informadas são habilidades necessárias para enfrentar os desafios
do desenvolvimento de software. A colaboração entre a equipe de desenvolvimento e a gerência
é fundamental para alinhar o projeto com as metas e requisitos.

O gerente de projetos de software deve possuir uma combinação de habilidades técnicas e

interpessoais. Além das competências técnicas em gerenciamento de projetos e conhecimento
de engenharia de software, as habilidades de liderança são essenciais para inspirar e motivar a
equipe. A eficiência na comunicação é fundamental para garantir que todos os membros da
equipe compreendam seus papéis e responsabilidades. A capacidade de negociação é valiosa
para lidar com requisitos conflitantes e demandas dos stakeholders. Estimular as habilidades da
equipe, promovendo um ambiente colaborativo e criativo, é um aspecto crucial do papel do
gerente de projetos.

Semana 4 - Padrões importantes da Web, HTML, JSON e Python

Histórico e Padrões clássicos da Web, HTML5, CSS3, JSon

Vannevar Bush e a criação do conceito de hipertexto

Vannevar Bush foi uma das figuras pioneiras no campo da computação e da informática. Ele é
amplamente reconhecido por seu trabalho no desenvolvimento do conceito de hipertexto, que
é a ideia de que informações podem ser interconectadas e navegadas de maneira não linear. Em
seu famoso artigo "As We May Think", publicado em 1945, Bush apresentou a memex, uma
máquina teórica que permitiria aos usuários acessar e vincular informações de maneira
semelhante ao que hoje conhecemos como hiperlinks na web.

Ted Nelson e o termo hipertexto e o Xanadu

Ted Nelson, outro pioneiro na computação, é conhecido por cunhar o termo "hipertexto". Ele
defendeu a visão de um sistema chamado Xanadu, que pretendia ser uma rede global de
documentos interconectados, onde os links seriam bidirecionais, permitindo que os autores
mantivessem o controle sobre seus próprios conteúdos, independentemente de onde fossem
vinculados.

Douglas Engelbart e a computação interativa

Douglas Engelbart é famoso por sua demonstração "Mother of All Demos" em 1968, onde ele
introduziu uma série de conceitos revolucionários, incluindo o mouse, a interface gráfica de

14
usuário e a edição de texto interativa. Essas inovações formaram a base para a forma como
interagimos com os computadores hoje em dia.

Tim Berners-Lee e o sistema Mesh, WWW e formalização do HTML

Tim Berners-Lee é o criador da World Wide Web (WWW) e uma figura crucial na história da
computação. Ele propôs o sistema Mesh, que serviu como a base para a World Wide Web que
conhecemos hoje. Berners-Lee também desempenhou um papel fundamental na formalização
da linguagem HTML (HyperText Markup Language), que é a espinha dorsal da web moderna.

W3C

O World Wide Web Consortium (W3C) é uma organização internacional que foi fundada por Tim
Berners-Lee em 1994. O W3C é responsável por estabelecer padrões abertos para a web,
garantindo a interoperabilidade e acessibilidade dos recursos web em diferentes plataformas e
navegadores.

Rich Internet Application (RIA)

As Rich Internet Applications são aplicativos web avançados que oferecem uma experiência de
usuário mais rica e interativa do que os aplicativos web tradicionais. Eles geralmente usam
tecnologias como AJAX, Flash ou HTML5 para oferecer funcionalidades sofisticadas, como
animações, gráficos e interatividade em tempo real.

Padrões Web

Os padrões web, como HTML (linguagem de marcação), CSS (folhas de estilo em cascata),
JavaScript (linguagem de programação do lado do cliente) e tecnologias relacionadas como Ajax
(Asynchronous JavaScript and XML), XML (Extensible Markup Language) e JSON (JavaScript
Object Notation), são a espinha dorsal do desenvolvimento web. Eles permitem que os
desenvolvedores criem sites e aplicativos web compatíveis e funcionais em diferentes
navegadores e dispositivos.

Bibliotecas e Frameworks

Bibliotecas e frameworks são conjuntos de código pré-escrito que os desenvolvedores podem

usar para acelerar o desenvolvimento de aplicativos.

jQuery simplifica a manipulação do DOM (Document Object Model)

Vantagens:

● Compatibilidade Cross-Browser: O jQuery lida com diferenças de comportamento entre

navegadores, tornando o código mais consistente em diferentes ambientes.
● Grande Comunidade: Há uma vasta comunidade de desenvolvedores que contribuem
com plugins e suporte, facilitando a resolução de problemas e a obtenção de recursos
adicionais.
● Ampla Documentação: O jQuery possui documentação extensa e exemplos prontos
para uso, o que ajuda os desenvolvedores a aprenderem rapidamente e a encontrar
soluções para problemas comuns.
● Performance Melhorada: O jQuery otimiza muitas operações para melhorar o
desempenho, permitindo a criação de aplicações web mais rápidas.

15
Desvantagens:

● Tamanho do Arquivo: O jQuery tem um tamanho considerável em termos de arquivo,

o que pode afetar o tempo de carregamento da página, especialmente em conexões
lentas.
● Dependência Externa: Usar jQuery significa depender de uma biblioteca externa, o que
pode aumentar a complexidade e a sobrecarga de recursos em projetos pequenos.
● Manutenção: À medida que os navegadores modernos continuam a melhorar o suporte
nativo para JavaScript e manipulação do DOM, a necessidade do jQuery diminui,
tornando-o menos relevante e mais difícil de manter.
● Limitações de Recursos: Para tarefas altamente personalizadas ou complexas, o jQuery
pode não fornecer todas as funcionalidades necessárias, levando a soluções
personalizadas ou à utilização de JavaScript puro.
● Performance em Dispositivos Móveis: Em dispositivos móveis, o jQuery pode ser mais
lento do que o JavaScript nativo, o que pode afetar negativamente a experiência do
usuário.

React é uma biblioteca JavaScript para criação de interfaces de usuário.

Vantagens:

● Componentização: O React utiliza componentes reutilizáveis que facilitam a

organização do código e a manutenção.
● Virtual DOM: O Virtual DOM do React otimiza o desempenho, minimizando as
atualizações do DOM real, tornando as aplicações mais rápidas.
● Flexibilidade: Pode ser usado com outras bibliotecas e frameworks, permitindo escolher
as ferramentas mais adequadas para o projeto.
● Grande Comunidade: Possui uma comunidade ativa e vasta documentação, o que
facilita a aprendizagem e solução de problemas.

Desvantagens:

● Configuração Necessária: O React em si é apenas uma biblioteca de visualização, então

requer configuração adicional para um projeto completo.
● Gerenciamento de Estado: O gerenciamento de estado pode ser complexo, exigindo
bibliotecas adicionais como Redux.

Bootstrap fornece estilos e componentes prontos para uso.

Vantagens:

● Rápido Desenvolvimento: Permite criar interfaces de usuário responsivas rapidamente

com o uso de classes CSS predefinidas.
● Componentes Prontos: Oferece uma ampla variedade de componentes de interface de
usuário, como botões, formulários e carrosséis, economizando tempo de
desenvolvimento.
● Base CSS Sólida: Fornecer uma base CSS consistente para garantir a compatibilidade
cruzada do design.
● Documentação Abundante: Contém documentação detalhada e exemplos prontos para
uso.

Desvantagens:

16
 ● Estilo Genérico: Pode resultar em sites com aparência semelhante, a menos que
personalizado, o que pode não ser ideal para projetos que requerem designs exclusivos.
● Tamanho do Arquivo: O Bootstrap pode ser pesado em termos de tamanho de arquivo,
afetando o tempo de carregamento da página.
● Personalização Limitada: Personalizar o Bootstrap para atender às necessidades
específicas do projeto pode ser desafiador, às vezes resultando em CSS adicional.

Angular é um framework TypeScript para o desenvolvimento de aplicativos web e móveis.

Vantagens:

● Framework Completo: O Angular é um framework completo que oferece um conjunto

abrangente de ferramentas para desenvolvimento web, incluindo gerenciamento de
estado, roteamento e injeção de dependência.
● TypeScript: O Angular é escrito em TypeScript, o que melhora a manutenção e a
detecção de erros no código.
● Performance: Possui otimizações de desempenho, como detecção de mudanças
eficiente e Lazy Loading.
● Segurança: O Angular possui recursos integrados de segurança, como proteção contra
injeção de código.

Desvantagens:

● Tamanho do Pacote: Aplicativos Angular podem ter um tamanho considerável, o que

pode afetar o tempo de carregamento.
● Manutenção: Projetos Angular podem exigir mais manutenção devido à sua
complexidade.

Áreas de Atuação no Desenvolvimento Web

No desenvolvimento web, existem várias áreas de atuação. O front-end se concentra na criação

da interface do usuário e na experiência do usuário. O back-end lida com a lógica de servidor,
gerenciamento de banco de dados e processamento de solicitações do usuário. Os
desenvolvedores de aplicativos se concentram em criar aplicativos para dispositivos móveis ou
de desktop. Os desenvolvedores full-stack têm habilidades tanto front-end quanto back-end,
permitindo que trabalhem em todos os aspectos de um projeto web.

Framework Python - Django

Django é um framework de desenvolvimento web em Python. Ele fornece um conjunto de

ferramentas e padrões para facilitar a criação de aplicativos web robustos e escaláveis. Django
é conhecido por sua simplicidade e eficiência, tornando-o uma escolha popular para
desenvolvedores que desejam acelerar o desenvolvimento de aplicativos web com Python.

Semana 5 - Framework Python, APIs e Web Services

Framework Phyton

Flask: Simplicidade e Flexibilidade no Desenvolvimento

17
O Flask é um framework escrito em Python conhecido por sua simplicidade e flexibilidade no
desenvolvimento de aplicativos web. Ao contrário de alguns outros frameworks mais
complexos, o Flask segue uma abordagem minimalista, dando aos desenvolvedores a liberdade
de escolher as bibliotecas e ferramentas que desejam usar em seus projetos.

A simplicidade do Flask o torna uma ótima escolha para iniciantes, pois é fácil de aprender e
permite que você comece a construir aplicativos web rapidamente. No entanto, essa
simplicidade não significa falta de recursos. O Flask é altamente extensível e permite que você
adicione funcionalidades conforme necessário, o que o torna adequado para uma variedade de
projetos, desde pequenas aplicações até sistemas web mais complexos.

Monark: Facilitando o Desenvolvimento de Aplicativos Web Dinâmicos

Monark é um framework de código aberto que se destaca por sua capacidade de facilitar o
desenvolvimento de aplicativos web dinâmicos. Assim como o Flask, o Monark é escrito em
Python, tornando-o acessível para a vasta comunidade de desenvolvedores Python.

O Monark fornece uma estrutura sólida para criar aplicativos web interativos e dinâmicos. Ele
simplifica tarefas comuns, como a manipulação de requisições HTTP, a interação com bancos de
dados e a criação de interfaces de usuário responsivas. Isso permite que os desenvolvedores
foquem mais na lógica de negócios de seus aplicativos e menos na infraestrutura técnica.

Django e Web Services: Facilitando a Integração de Dados

O Django Rest Framework é uma extensão poderosa que simplifica a criação de APIs RESTful.
Essa estrutura facilita o tratamento de verbos HTTP (como GET, POST, PUT e DELETE) e códigos
de status, tornando a criação de APIs eficiente e intuitiva. Além disso, o Django Rest Framework
oferece suporte para manipulação de dados em formatos populares, como JSON e XML, o que
é essencial para a integração de dados com outros sistemas e serviços.

Camadas de Desenvolvimento: Model, View, Controller (MVC) e Model, View, Template

(MVT)

É importante mencionar o conceito de camadas de desenvolvimento. Esse conceito é comum

em muitos frameworks web, eles seguem a arquitetura Model-View-Controller (MVC), onde:

● Model: Representa a camada de dados, incluindo a definição de modelos de banco de

dados.
● View: Lida com a lógica de apresentação e interação do usuário.
● Controller: Controla o fluxo de dados entre o Model e a View.

Essa separação de responsabilidades facilita a organização e manutenção de aplicativos web,

tornando-os mais escaláveis e fáceis de gerenciar.

O Django segue uma arquitetura de camadas de desenvolvimento conhecida como Model-View-

Template (MVT), que é semelhante à arquitetura Model-View-Controller (MVC). No Django, as
camadas são definidas da seguinte forma:

● Model: Responsável pelo gerenciamento dos dados e interações com o banco de dados.
● View: Lida com a lógica de apresentação e processamento de solicitações do usuário.
● Template: Responsável pela renderização das páginas HTML e pela apresentação dos
dados ao usuário.

18
APIs e Web Services
APIs (Interfaces de Programação de Aplicativos):

As APIs são essenciais para a interação entre diferentes partes de um único aplicativo ou
dispositivo. Elas definem como os diferentes componentes ou módulos de um software se
comunicam entre si. Por exemplo, um aplicativo de edição de fotos pode ter APIs que permitem
que a parte de edição interaja com a parte de salvamento.

Web Services (Serviços Web):

Os Web Services, por outro lado, são projetados para permitir a comunicação entre sistemas
distintos em uma rede, muitas vezes através da internet. Eles funcionam como "pontes" que
conectam sistemas heterogêneos, independentemente de suas tecnologias, plataformas e
linguagens de programação. Em resumo, os Web Services promovem a interconexão de
sistemas em escala global.

Principais diferenças:

A principal diferença entre APIs e Web Services reside na sua acessibilidade e escopo de
utilização. As APIs são voltadas para a comunicação interna de um único dispositivo ou
aplicativo, enquanto os Web Services são destinados a conectar sistemas distribuídos em uma
rede, incluindo a internet. Os Web Services também são capazes de transferir dados entre
sistemas, tornando-os ideais para integrações entre aplicativos e sistemas independentes.

Padrões da Web:

XML (Extensible Markup Language):

O XML é um formato padronizado amplamente utilizado para armazenar e transportar dados.

Ele é semelhante ao HTML, mas sua ênfase está na estruturação e organização de informações
de maneira genérica e independente de plataforma. O XML é frequentemente utilizado em Web
Services para representar e transmitir dados de forma estruturada.

JSON (JavaScript Object Notation):

O JSON é outra notação padronizada para armazenamento e transferência de dados. Ele se

baseia na representação de objetos e arrays em JavaScript, mas é independente da linguagem.
Devido à sua simplicidade e eficiência, o JSON ganhou popularidade em APIs e Web Services,
especialmente em aplicativos da web.

HTTP (Hypertext Transfer Protocol):

O HTTP é o protocolo fundamental para a transferência de dados na internet. Ele define como
as mensagens devem ser formatadas e transmitidas entre clientes (geralmente navegadores) e
servidores web. Os Web Services frequentemente utilizam o HTTP como protocolo de
comunicação para permitir a transferência de dados pela rede.

Comunicação entre Sistemas:

A comunicação entre sistemas é um aspecto crítico para o funcionamento de Web Services. Ela
ocorre da seguinte maneira:

19
 ● O aplicativo cliente envia uma solicitação de operação para o Web Service.
● O Web Service processa a solicitação, realiza as operações necessárias e prepara os
dados para envio.
● Os dados processados são enviados de volta para o aplicativo cliente, que os interpreta
e utiliza conforme necessário.

Protocolos de Comunicação:

Dois dos protocolos de comunicação mais comuns utilizados em Web Services são SOAP (Simple
Object Access Protocol) e REST (Representational State Transfer). O SOAP é conhecido por sua
estrutura rigorosa e capacidade de suportar mensagens complexas, enquanto o REST é
valorizado por sua simplicidade e alto desempenho.

WSDL (Web Service Definition Language):

O WSDL é uma linguagem que descreve a localização do Web Service e as operações que ele
oferece. Ele é frequentemente usado para documentar e definir os aspectos técnicos de um
Web Service, tornando a integração mais fácil para os desenvolvedores.

Semana 6 -Internet das Coisas (IoT) e os protocolos MQTT e REST

Internet das Coisas (loT)

A Internet das Coisas (IoT) é uma revolução tecnológica que tem como objetivo conectar
objetos físicos do nosso cotidiano à internet, equipando-os com tecnologia embarcada e
sensores. Essa interconexão permite que esses objetos coletem e compartilhem dados,
tornando-os mais inteligentes e eficientes em suas funcionalidades. Nos últimos anos, o IoT
tem ganhado destaque devido a avanços tecnológicos significativos, ao barateamento dos
dispositivos e à sua popularização.

Dentro do universo da IoT, várias áreas de pesquisa se destacam. A aquisição de dados é

fundamental, pois os sensores embutidos nos objetos coletam informações sobre entidades
físicas, como temperatura, umidade, luminosidade e pressão, entre outras variáveis. A análise
em tempo real e offline desses dados é crucial para extrair insights e tomar decisões
informadas. Além disso, o aprendizado de máquina e a visualização de dados desempenham
um papel importante na compreensão dos padrões e tendências identificados pelos sensores,
enquanto o Big Data lida com o processamento de grandes volumes de informações geradas
pelos dispositivos IoT.

Alguns conceitos-chave na IoT incluem:

Coisa: Refere-se a objetos físicos do dia a dia, que podem variar de eletrodomésticos a
dispositivos urbanos, como semáforos e câmeras de vigilância.

Dispositivo: São os componentes fundamentais da IoT e podem ser sensores ou atuadores.

Sensores coletam dados, enquanto atuadores realizam ações com base nesses dados.

Conectividade: Para que a IoT funcione, é essencial que os dispositivos estejam conectados à
internet. Isso pode ser alcançado por meio de tecnologias como Bluetooth, 3G, 4G e 5G.

20
Arquitetura genérica: A fim de padronizar o funcionamento dos dispositivos IoT, uma
arquitetura genérica é adotada. Isso permite que diferentes dispositivos se comuniquem de
maneira eficiente e consistente.

A arquitetura de IoT geralmente envolve a coleta de dados por sensores embutidos nos
objetos físicos. Esses dados são então enviados para um back-end, onde são armazenados e
processados. Essa arquitetura genérica pode ser aplicada a uma ampla gama de áreas de
aplicação, incluindo cidades inteligentes, monitoramento ambiental, agricultura de precisão,
cuidados de saúde e aplicações cotidianas, como dispositivos domésticos inteligentes.

O desenvolvimento de aplicativos para dispositivos IoT apresenta desafios únicos. Os

dispositivos IoT são frequentemente parte de sistemas maiores e heterogêneos, o que exige
uma abordagem de desenvolvimento adaptável. Além disso, a conectividade intermitente e a
dinâmica dos dispositivos IoT requerem uma consideração cuidadosa durante o
desenvolvimento de aplicativos. É importante notar que há diferenças significativas entre o
desenvolvimento de aplicativos móveis e web tradicionais.

No cenário brasileiro, a IoT tem se expandido com a implementação de políticas, como a lei
que zera impostos sobre produtos IoT. Além disso, a chegada da rede 5G de baixa latência
promete impulsionar ainda mais o desenvolvimento e a adoção de dispositivos IoT no país. No
entanto, o ritmo rápido da evolução tecnológica representa um desafio para acompanhar as
mudanças e atualizações necessárias para aproveitar ao máximo o potencial da IoT no Brasil.

MQTT e REST
Importância dos Protocolos:

Cruciais na Indústria 4.0 e Sistemas Embarcados: A Indústria 4.0, caracterizada pela

automação avançada e integração de sistemas, depende fortemente de protocolos para
permitir a comunicação eficiente entre máquinas e sistemas. Isso resulta em processos mais
eficientes, controle de qualidade aprimorado e economia de recursos.

Revolução na IoT: A Internet das Coisas (IoT) tem transformado a maneira como interagimos
com dispositivos cotidianos, desde termostatos inteligentes até carros conectados. Protocolos
desempenham um papel vital ao permitir que esses dispositivos se comuniquem e
compartilhem informações, tornando nossas vidas mais convenientes e eficientes.

Conexão com a Internet: A capacidade de conectar dispositivos à internet é essencial em um

mundo cada vez mais digital. Os protocolos possibilitam essa conexão, permitindo que
dispositivos coletem e compartilhem dados em tempo real, habilitando uma ampla gama de
aplicativos e serviços online.

MQTT (Message Queuing Telemetry Transport):

O MQTT é um protocolo notável, conhecido por sua eficiência e leveza. Ele é especialmente
adequado para comunicações máquina a máquina (M2M) e é caracterizado pelos seguintes
pontos:

Leveza: O MQTT é projetado para consumir recursos mínimos, tornando-o ideal para
dispositivos com restrições de energia e recursos.

21
Publicação e Assinatura: Seu modelo de publicação e assinatura simplifica a comunicação,
permitindo que dispositivos enviem mensagens e outros dispositivos as recebam, conforme
necessário.

Diversas Aplicações: O MQTT é amplamente aplicado em setores como automotivo, logística,

monitoramento de drones e casas inteligentes, onde a comunicação eficiente é essencial.

REST (Representational State Transfer):

O REST é um protocolo baseado na arquitetura web, que é altamente utilizado na

conectividade da IoT. Suas características incluem:

Interfaces Bem Definidas: O REST permite a criação de interfaces de transmissão de dados

bem definidas, tornando-o adequado para o desenvolvimento de projetos IoT.

Confiabilidade e Rapidez: É uma escolha confiável e rápida para conectar dispositivos IoT à
internet, facilitando a troca de informações e análise de dados em tempo real.

Comparação entre MQTT e REST:

MQTT: Oferece conexões bilaterais, baixo consumo de energia, conexão persistente e taxa de
transferência rápida, suportando até 50 mil conexões simultâneas.

REST: Possui conexão unidirecional, um maior consumo de energia, requer estabelecimento de

conexão a cada transferência e oferece uma taxa de transferência mais lenta.

Outros Protocolos de Comunicação:

Além do MQTT e do REST, existem inúmeros outros protocolos de comunicação, muitos dos
quais baseados no modelo TCP/IP. Alguns exemplos incluem 6LoWPAN e CoAP, que se
adequam a diversas aplicações específicas.

Emuladores e Simuladores:

Para desenvolver e testar projetos IoT, emuladores e simuladores desempenham um papel

crucial, permitindo que os desenvolvedores trabalhem em ambientes virtuais. Um exemplo
popular é o Eclipse IoT, que fornece ferramentas para modelagem, execução e análise de
simulações, tornando o desenvolvimento mais acessível e eficiente.

Semana 7

Ciência de Dados
A Ciência de Dados é uma disciplina que se tornou essencial em um mundo movido por
informações e tecnologia. Ela é definida como o estudo disciplinado de dados e informações em

22
diferentes tipos de negócios. Para entender completamente a Ciência de Dados, é importante
considerar as disciplinas envolvidas, que abrangem Ciências da Computação, Estatística,
Matemática e conhecimentos de negócios.

A importância da Ciência de Dados é inegável, especialmente considerando o grande volume de

dados disponíveis atualmente. Estima-se que até 2023, teremos mais de 103 zettabytes de
dados à nossa disposição. Isso representa uma oportunidade incrível para explorar informações
valiosas e insights em diversos setores.

No entanto, é crucial distinguir entre Ciência de Dados, Data Analytics e Big Data. Embora todas
lidem com dados, cada uma tem abordagens específicas para lidar com dados brutos. A Ciência
de Dados envolve análises complexas e métodos avançados, exigindo habilidades em estatística,
programação e um profundo conhecimento de negócios. Data Analytics concentra-se em
examinar dados brutos para extrair conclusões e informações valiosas. Por outro lado, Big Data
lida com volumes massivos de dados que não podem ser processados usando métodos
convencionais, exigindo ferramentas e abordagens especializadas.

As aplicações da Ciência de Dados são vastas e impactam muitos setores. Nos bancos, a Ciência
de Dados é fundamental para a gestão de recursos e a detecção de fraudes. Nas finanças, ela
desempenha um papel crucial na análise de riscos e na análise preditiva. Na manufatura,
contribui para aumentar a eficiência e reduzir custos. No setor de transporte, a Ciência de Dados
está tornando as estradas mais seguras e impulsionando o desenvolvimento de veículos
autônomos. Na área de saúde, ajuda na análise de imagens médicas e diagnósticos avançados.
No comércio eletrônico, é usada para analisar o comportamento dos clientes e definir preços
competitivos.

A carreira em Ciência de Dados oferece várias vantagens, incluindo alta demanda no mercado
de trabalho, salários elevados, versatilidade e a capacidade de melhorar a qualidade dos
produtos e serviços. No entanto, também possui desafios, como a falta de uma definição clara
devido à sua natureza interdisciplinar, a necessidade de conhecimento diversificado, a
manipulação de dados muitas vezes arbitrários e preocupações éticas relacionadas à
privacidade dos dados dos clientes.

As questões éticas em Ciência de Dados são particularmente relevantes, já que o uso

inadequado de dados pode violar a privacidade dos clientes. Garantir a preservação e o uso
responsável dos dados é uma preocupação crescente, pois a Ciência de Dados desempenha um
papel cada vez mais importante em nossa sociedade.

Ciência de Dados e Python

Vamos agora consolidar todo o aprendizado desta aula e das aulas anteriores em um projeto
prático. Este projeto consiste em realizar a leitura de dispositivos de IoT distribuídos nos diversos
polos da Univesp e aplicar técnicas de Ciência de Dados para processar os dados coletados. Para
a execução desse projeto, utilizaremos a plataforma Google Colab e o código disponibilizado a
seguir.
!pip install arrow

# Lendo as bibliotecas
from oauthlib.oauth2 import BackendApplicationClient
from requests_oauthlib import OAuth2Session

23
import numpy as np
import pandas as pd
import arrow
from pandas import json_normalize
import json
import glob
import matplotlib.pyplot as plt

# Definindo as funcoes para uso da API da Plataforma

def get_data(application,guid,timestamp_init,timestamp_final):
result = []
i = 0
lastlen=10000
while timestamp_init < timestamp_final:
stats =
oauth.get("https://api.demo.konkerlabs.net/v1/{}/incomingEvents?q=d
evice:{}timestamp:>{}&sort=oldest&limit=10000".format(application,g
uid,timestamp_init)).json()['result']
if (len(stats)<2) and (lastlen<10000):
break
timestamp_init = stats[-1]['timestamp']
result.extend(stats)
lastlen = len(stats)
print(timestamp_init)
return result

def list_devices(oauth):
global base_api
devices =
oauth.get("https://api.demo.konkerlabs.net/v1/{}/devices/?size=5000
".format(application)).json()['result']
return devices

# Inserindo os dados da conta na plataforma (importante não passar

esse notebook para pessoas externas)
base_api = 'https://api.demo.konkerlabs.net'
application = 'univesp'
username = ''
password = ''

#Autenticando e pegando o token de acesso a conta

client = BackendApplicationClient(client_id=username)
oauth = OAuth2Session(client=client)
token =
oauth.fetch_token(token_url='{}/v1/oauth/token'.format(base_api),cl
ient_id=username,client_secret=password)

# Listando os dispositivos dessa conta.

# Cada dispositivo possuí um sensor DHT22 e está localizado em um
dos polos da Univesp.
# Existem dispositivos que não tem dados, pois nunca foram ligados,
bem como alguns com dados intermitentes,
# que funcionam por um período e estão desligados por outros.
dev_list = list_devices(oauth)

#Vamos olhar agora os metadados de dispositvos.

dev_list

24
stats_df

# Vamos agora examinar os dados dos dispositivos

stats_df.groupby(['incoming.channel']).count()

# Vamos dar uma olhada nos dados de temperatura e umidade

fig, ax1 = plt.subplots(figsize=(20,10))
plt.rcParams.update({'font.size': 22})
plt.gca().xaxis_date('America/Sao_Paulo')
plt.rcParams['timezone'] = 'America/Sao_Paulo'
plt.title('Temperatura e umidade do dispositivo S8V0200A0B4B7',
size=32, y=1.02)
ax1.plot(stats_df[stats_df['incoming.channel']=='data']['payload.te
mperature'],color='red',alpha=1, linewidth=1)
ax1.set_ylabel('Temperatura [$^\circ$C]', size=24, color = 'red')
ax1.set_xlabel('Data', size=24)
plt.grid()
for tl in ax1.get_yticklabels():
tl.set_color('r')
fig.tight_layout()
labels = ax1.get_xticklabels()
ax2 = ax1.twinx()
ax2.plot(stats_df[stats_df['incoming.channel']=='data']['payload.hu
midity'],color='blue', linewidth=1)
ax2.set_ylabel('Umidade [%]', size=24, color = 'blue')
for tl in ax2.get_yticklabels():
tl.set_color('b')
fig.tight_layout()
labels = ax1.get_xticklabels()
plt.setp(labels, rotation=45, fontsize=22)
plt.show()

25