DEV Community: Rita Carolina

Automatize sua Revisão: Extração de BibTeX em massa do Springer com Python e ChatGPT

Rita Carolina — Tue, 15 Apr 2025 01:20:43 +0000

🚀 Automatize sua Revisão: Extração de BibTeX em massa do Springer com Python e ChatGPT

Realizar revisões sistemáticas ou construir um repositório bibliográfico de forma eficiente pode ser um desafio, especialmente quando os repositórios acadêmicos não oferecem exportação em lote das citações. Com base nessa dor real, desenvolvi — com apoio do ChatGPT — um script completo que automatiza a extração de referências do SpringerLink via RSS e as transforma em um arquivo .bib pronto para uso no Rayyan, Zotero, Overleaf, entre outros.

Abaixo explico como funciona e como você pode executar o código em poucos minutos no Google Colab ou localmente no seu terminal.

🧠 O que o script faz?

Acessa o RSS de busca do Springer com os filtros definidos (tema, data, idioma, tipo de publicação).
Percorre várias páginas automaticamente (você define quantas).
Extrai os DOIs de cada artigo publicado.
Consulta a API do CrossRef usando content negotiation para obter o BibTeX.
Salva tudo em um único arquivo .bib.

✅ Como rodar no Google Colab

Acesse o Google Colab
Crie um novo notebook e cole o código abaixo
Rode célula por célula
Faça o download do arquivo .bib gerado ao final

💻 Código completo

import requests
import xml.etree.ElementTree as ET
from tqdm import tqdm

def get_dois_from_rss(page_limit=10):
    base_url = "https://link.springer.com/search.rss"
    query_params = {
        "new-search": "true",
        "query": '( "process management" OR "business process management" ) AND ( "artificial intelligence" OR "AI" OR "machine learning" OR "deep learning" OR "neural networks" OR "generative AI" )',
        "content-type": ["Conference Paper", "Article", "Research"],
        "language": "En",
        "date": "custom",
        "dateFrom": "2020",
        "dateTo": "2025",
        "sortBy": "relevance"
    }

    all_dois = []

    for page in range(1, page_limit + 1):
        query_params["page"] = str(page)
        print(f"🔄 Buscando página {page}...")
        try:
            response = requests.get(base_url, params=query_params)
            if response.status_code != 200:
                print(f"⚠️ Falha ao acessar página {page}: {response.status_code}")
                break
            root = ET.fromstring(response.content)
            items = root.findall(".//item")
            if not items:
                print("🚫 Nenhum item encontrado. Parando paginação.")
                break
            for item in items:
                guid = item.find("guid")
                if guid is not None and guid.text.startswith("10."):
                    print(f"✅ DOI encontrado: {guid.text}")
                    all_dois.append(guid.text)
        except Exception as e:
            print(f"❌ Erro na página {page}: {e}")
            break

    return all_dois

def fetch_bibtex(dois):
    bibtex_entries = []
    headers = {"Accept": "application/x-bibtex"}
    for doi in tqdm(dois, desc="🔃 Baixando BibTeX via CrossRef"):
        try:
            r = requests.get(f"https://doi.org/{doi}", headers=headers, timeout=10)
            if r.status_code == 200:
                bibtex_entries.append(r.text)
        except Exception as e:
            print(f"Erro ao buscar BibTeX para DOI {doi}: {e}")
    return bibtex_entries

# 🔧 Executar
dois_coletados = get_dois_from_rss(page_limit=20)
bibtex_data = fetch_bibtex(dois_coletados)

# 💾 Salvar
with open("springer_all_pages.bib", "w", encoding="utf-8") as f:
    for entry in bibtex_data:
        f.write(entry + "\n\n")

print(f"\n✅ Arquivo gerado: springer_all_pages.bib ({len(bibtex_data)} entradas)")

📌 Personalize conforme sua busca

Você pode alterar facilmente:

O termo da query (ex: "process mining" ou "knowledge graph")
O intervalo de tempo (dateFrom, dateTo)
O número de páginas (page_limit=20)

📎 Resultado

Ao final da execução, você terá um arquivo chamado:

springer_all_pages.bib

Pronto para subir no Rayyan, importar no Zotero ou usar em seu projeto em LaTeX.

🧠 Por que usar esse script?

Evita o trabalho manual de baixar artigo por artigo.
Garante alta confiabilidade (dados vindos direto da CrossRef).
Ideal para quem faz revisão sistemática, mapeamento ou meta-análise.

Se quiser adaptar o script para outras bases com RSS, como IEEE Xplore ou PubMed, também é possível. E claro, o ChatGPT pode te ajudar nisso também. 😉

Nova versão que extrai com abstract

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import requests
import xml.etree.ElementTree as ET
from tqdm import tqdm
import json
import re


def get_rss_from_springer(page_limit=10):
    """Extrai RSS do Springer página por página"""
    base_url = "https://link.springer.com/search.rss"
    query_params = {
        "new-search": "true",
        "query": '''
        ("implicit dependencies" OR "hidden dependencies" OR "undocumented dependencies" OR "implicit relationships" OR "hidden relationships" OR "activity relationships"
        OR "process relationships" OR "tacit dependencies" OR "emergent dependencies") AND ("business process*" OR "organizational process*" OR "process model*"
        OR "process redesign" OR "process reengineering" OR "workflow*" OR "BPMN")
        ''',
        "content-type": ["Conference Paper", "Article", "Research"],
        "language": "En",
        "date": "custom",
        "dateFrom": "2020",
        "dateTo": "2025",
        "sortBy": "relevance"
    }

    all_items = []

    for page in range(1, page_limit + 1):
        query_params["page"] = str(page)
        print(f"🔄 Página {page}...")
        try:
            response = requests.get(base_url, params=query_params, timeout=15)
            if response.status_code != 200:
                print(f"⚠️ Erro: {response.status_code}")
                break

            root = ET.fromstring(response.content)
            items = root.findall(".//item")

            if not items:
                print("🚫 Sem mais itens. Parando.")
                break

            all_items.extend(items)
            print(f"✅ {len(items)} artigos")

        except Exception as e:
            print(f"❌ Erro: {e}")
            break

    return all_items


def extract_article_data(item):
    """Extrai: título, DOI, abstract da tag <description>"""
    data = {}

    title = item.find("title")
    data['title'] = title.text if title is not None else "N/A"

    guid = item.find("guid")
    data['doi'] = guid.text if guid is not None else "N/A"

    desc = item.find("description")
    if desc is not None:
        parts = []
        if desc.text:
            parts.append(desc.text)
        for child in desc:
            if child.text:
                parts.append(child.text)
            if child.tail:
                parts.append(child.tail)

        abstract = ' '.join(parts)
        abstract = re.sub(r'<[^>]+>', '', abstract)
        abstract = re.sub(r'\s+', ' ', abstract).strip()
        data['abstract'] = abstract
    else:
        data['abstract'] = ""

    print(f"DEBUG - Abstract extraído para '{data['title']}...': {data['abstract']}...")

    link = item.find("link")
    data['link'] = link.text if link is not None else "N/A"

    return data


def fetch_crossref_data(doi):
    """Busca dados do CrossRef para enriquecer o BibTeX"""
    try:
        url = f"https://api.crossref.org/works/{doi}"
        response = requests.get(url, timeout=10)

        if response.status_code == 200:
            return response.json()
        return None
    except:
        return None


def extract_from_crossref(metadata):
    """Extrai campos úteis do CrossRef"""
    data = {
        'authors': [],
        'journal': '',
        'volume': '',
        'issue': '',
        'pages': '',
        'year': '',
        'abstract': ''
    }

    if not metadata or 'message' not in metadata:
        return data

    msg = metadata['message']

    try:
        for author in msg.get('author', []):
            name_parts = []
            if 'given' in author:
                name_parts.append(author['given'])
            if 'family' in author:
                name_parts.append(author['family'])
            if name_parts:
                data['authors'].append(' '.join(name_parts))
    except:
        pass

    try:
        container = msg.get('container-title', [])
        data['journal'] = container[0] if isinstance(container, list) else container
    except:
        pass

    data['volume'] = msg.get('volume', '')
    data['issue'] = msg.get('issue', '')
    data['pages'] = msg.get('page', '')

    try:
        if 'issued' in msg and 'date-parts' in msg['issued']:
            date_parts = msg['issued']['date-parts'][0]
            data['year'] = str(date_parts[0]) if date_parts else ''
    except:
        pass

    data['abstract'] = msg.get('abstract', '')

    return data


def generate_bibtex(article, crossref_data):
    """Gera entrada BibTeX completa"""
    key = article['doi'].replace('/', '_').replace('.', '_')

    bibtex = f"@article{{{key},\n"
    bibtex += f"  title = {{{article['title']}}},\n"

    if crossref_data and crossref_data['authors']:
        bibtex += f"  author = {{{' and '.join(crossref_data['authors'])}}},\n"

    if crossref_data and crossref_data['journal']:
        bibtex += f"  journal = {{{crossref_data['journal']}}},\n"

    if crossref_data and crossref_data['volume']:
        bibtex += f"  volume = {{{crossref_data['volume']}}},\n"

    if crossref_data and crossref_data['issue']:
        bibtex += f"  issue = {{{crossref_data['issue']}}},\n"

    if crossref_data and crossref_data['pages']:
        bibtex += f"  pages = {{{crossref_data['pages']}}},\n"

    if crossref_data and crossref_data['year']:
        bibtex += f"  year = {{{crossref_data['year']}}},\n"

    bibtex += f"  doi = {{{article['doi']}}},\n"
    bibtex += f"  url = {{{article['link']}}},\n"

    abstract = article['abstract']
    if not abstract and crossref_data:
        abstract = crossref_data['abstract']

    if abstract:
        abstract_clean = abstract.replace('"', '\\"').replace('\n', ' ')
        bibtex += f"  abstract = {{{abstract_clean}}}\n"
    else:
        bibtex = bibtex.rstrip(',\n') + "\n"

    bibtex += "}\n"
    return bibtex


def main():
    print("\n" + "="*80)
    print("🔍 SPRINGER RSS → BIBTEX COM ABSTRACTS")
    print("="*80 + "\n")

    print("📋 Extraindo RSS...\n")
    items = get_rss_from_springer(page_limit=65)

    if not items:
        print("❌ Nenhum artigo encontrado")
        return

    print(f"\n✅ Total: {len(items)} artigos\n")

    print("🔍 Processando artigos...\n")
    articles = [extract_article_data(item) for item in items]

    print("📡 Buscando CrossRef e gerando BibTeX...\n")

    bibtex_list = []
    all_data = []

    for article in tqdm(articles, desc=""):
        metadata = fetch_crossref_data(article['doi'])
        crossref_data = extract_from_crossref(metadata) if metadata else {}

        bibtex = generate_bibtex(article, crossref_data)
        bibtex_list.append(bibtex)

        article['crossref'] = crossref_data
        article['bibtex'] = bibtex
        all_data.append(article)

    print("\n💾 Salvando...\n")

    with open("springer_articles.bib", "w", encoding="utf-8") as f:
        f.write("\n\n".join(bibtex_list))
    print(f"✅ springer_articles.bib ({len(bibtex_list)} entradas)")

    with open("springer_articles.json", "w", encoding="utf-8") as f:
        json.dump(all_data, f, indent=2, ensure_ascii=False)
    print(f"✅ springer_articles.json")

    print("\n" + "="*80)
    print("📊 RESUMO")
    print("="*80 + "\n")

    for i, article in enumerate(all_data[:5], 1):
        print(f"{i}. {article['title'][:60]}...")
        print(f"   DOI: {article['doi']}")
        if article['abstract']:
            print(f"   Abstract: {article['abstract'][:80]}...")
        print()

    if len(all_data) > 5:
        print(f"... +{len(all_data)-5} artigos\n")

    print("="*80)
    print(f"✅ Processados: {len(all_data)}")
    print(f"✅ Com abstract: {sum(1 for a in all_data if a['abstract'])}")
    print("="*80)


if __name__ == "__main__":
    main()

Subir aplicação web DJANGO em um servidor Linux 2/2

Rita Carolina — Thu, 23 Mar 2023 14:38:03 +0000

Configure o Gunicorn como um serviço do systemd (continuação):

Adicione a seguinte configuração, ajustando o caminho do ambiente virtual, o usuário e o grupo, conforme necessário:

[Unit]
Description=gunicorn daemon
After=network.target

[Service]
User=myuser
Group=mygroup
WorkingDirectory=/path/to/your/django/project
Environment="PATH=/path/to/your/virtualenv/bin"
ExecStart=/path/to/your/virtualenv/bin/gunicorn --access-logfile - --workers 3 --bind unix:/path/to/your/django/project/myproject.sock myproject.wsgi:application

[Install]
WantedBy=multi-user.target

Substitua /path/to/your/django/project pelo caminho absoluto do diretório do projeto Django.
Substitua /path/to/your/virtualenv pelo caminho absoluto do diretório do ambiente virtual.
Substitua myuser e mygroup pelos nomes de usuário e grupo apropriados.

Inicie e habilite o serviço Gunicorn:

Inicie o serviço Gunicorn: sudo systemctl start gunicorn.
Verifique o status do serviço Gunicorn: sudo systemctl status gunicorn.
Habilite o serviço Gunicorn para iniciar automaticamente após a reinicialização do servidor: sudo systemctl enable gunicorn.

Atualize a configuração do Nginx para usar o arquivo de soquete do Gunicorn:

Abra o arquivo de configuração do Nginx: sudo nano /etc/nginx/sites-available/myproject.
Modifique a linha proxy_pass para usar o arquivo de soquete:

proxy_pass http://unix:/path/to/your/django/project/myproject.sock;

Verifique se a configuração do Nginx está correta: sudo nginx -t.
Reinicie o Nginx: sudo systemctl restart nginx.

Configurar o firewall (opcional):

Se você estiver usando o ufw como firewall, permita conexões ao Nginx: sudo ufw allow 'Nginx Full'.

Teste sua aplicação web Django:

Acesse a aplicação web Django usando o endereço IP ou domínio do servidor no navegador.

Possíveis erros

Mantenha a coerência com o nome dos arquivos. Garanta que todos os endereços são os mesmos em todos os lugares.
Cheque se todos os arquivos estão com as configurações corretas Nginx: sudo nano /etc/nginx/sites-available/myproject Gunicorn: sudo nano /etc/systemd/system/gunicorn.service Hosts: sudo nano /etc/hosts Hostname: sudo nano /etc/hostname

Dicas

Revise todo o processo passo a passo para garantir que está alinhado. É importante que você entenda o que está acontecendo em cada processo.
Use da Inteligência Artificial do ChatGPT para resolver erros!

Parte 1: https://dev.to/feministech/subir-aplicacao-web-django-em-um-servidor-linux-12-58ec

Subir aplicação web DJANGO em um servidor Linux 1/2

Rita Carolina — Tue, 21 Mar 2023 17:12:30 +0000

Colocar no ar uma aplicação web Django em um servidor Linux envolve várias etapas. Aqui está um passo a passo detalhado para ajudá-lo nesse processo:

Prepare o servidor Linux:

Atualize o sistema operacional com os comandos sudo apt update e sudo apt upgrade.
Instale dependências necessárias: sudo apt install python3-pip python3-venv python3-dev libpq-dev.

Transfira o código da aplicação Django para o servidor:

Use um cliente SFTP, SCP ou Git para transferir o código-fonte do seu projeto Django para o servidor.

Configurar um ambiente virtual Python:

Crie um ambiente virtual: python3 -m venv myenv.
Ative o ambiente virtual: source myenv/bin/activate.
Instale as dependências do projeto: pip install -r requirements.txt.

Configure o arquivo settings.py do Django:

Modifique a variável ALLOWED_HOSTS para incluir o endereço IP ou domínio do seu servidor.
Configure o banco de dados, se necessário. Por exemplo, para um banco de dados PostgreSQL, instale a biblioteca psycopg2 e configure a variável DATABASES.

Migre o banco de dados e colete arquivos estáticos:

Execute as migrações: python manage.py migrate.
Colete os arquivos estáticos: python manage.py collectstatic.

Instale e configure o servidor web Gunicorn:

Instale o Gunicorn no ambiente virtual: pip install gunicorn.

Execute o Gunicorn para testar a aplicação: gunicorn --bind 0.0.0.0:8000 myproject.wsgi.

Configure o servidor web Nginx como proxy reverso:

Instale o Nginx: sudo apt install nginx.
Remova o link simbólico padrão do Nginx: sudo rm /etc/nginx/sites-enabled/default.
Crie um arquivo de configuração para o seu projeto: sudo nano /etc/nginx/sites-available/myproject.
Adicione a configuração do proxy reverso, substituindo "myproject" e "8000" pelos valores apropriados para o seu projeto:

server {
    listen 80;
    server_name mydomain.com;

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    location /static/ {
        alias /path/to/static/files/;
    }
}

Crie um link simbólico para o arquivo de configuração: sudo ln -s /etc/nginx/sites-available/myproject /etc/nginx/sites-enabled/.
Verifique se a configuração do Nginx está correta: sudo nginx -t.
Reinicie o Nginx: sudo systemctl restart nginx.

Continuação: https://dev.to/feministech/subir-aplicacao-web-django-em-um-servidor-linux-22-300g
Fonte: ChatGPT4.0

O que um documento de projeto de software normalmente inclui?

Rita Carolina — Wed, 18 Jan 2023 14:36:10 +0000

Visão geral do projeto: um resumo dos objetivos, escopo e entregas do projeto.

Requisitos: Uma descrição detalhada dos requisitos funcionais e não funcionais do software.

Design: Uma explicação do design geral do software, incluindo arquitetura do sistema, interface do usuário e design do banco de dados.

Implementação: Uma descrição das linguagens de programação, ferramentas e estruturas que serão usadas para implementar o software.

Teste: Um plano para testar o software, incluindo testes de unidade, testes de integração e testes de aceitação do usuário.

Implantação: Uma descrição do processo de implantação do software para produção, incluindo qualquer infraestrutura e operações necessárias.

Manutenção: Um plano para manter e atualizar o software após sua implantação.

Orçamento e cronograma: uma estimativa do tempo e dinheiro necessários para concluir o projeto.

Gerenciamento de riscos: Um plano para identificar e mitigar os riscos que podem surgir durante o projeto.

Comunicação e colaboração: um plano de como a equipe se comunicará e colaborará ao longo do projeto.

Como usar o google drive no google colab

Rita Carolina — Wed, 11 Jan 2023 17:02:05 +0000

Usar o Google Drive no google colab é extremamente eficiente pra quem quer executar seus algoritmos em alta velocidade de processamento.

Então vou deixar aqui alguns comandos que vai te auxiliar a integrar essa funcionalidade.

Importa a biblioteca do colab e monta o drive



from google.colab import drive
drive.mount('/content/drive')

Verifica se o diretório já existe



# Import das bibliotecas.
import os # Biblioteca para manipular arquivos

# ============================  
def verificaDiretorio():
    """
      Verifica se existe o diretório.    
    """

    # Verifica se o diretório existe
    if not os.path.exists(DIRETORIO):  
        # Cria o diretório
        os.makedirs(DIRETORIO)
        logging.info("Diretório criado: {}".format(DIRETORIO))

    return DIRETORIO

Importa bibliotecas de log



# Import das bibliotecas.
import logging # Biblioteca de logging

# Formatando a mensagem de logging
logging.basicConfig(format="%(asctime)s : %(levelname)s : %(message)s")

logger = logging.getLogger()
logger.setLevel(logging.INFO)

Verifica se está executando no google colab



# Import das bibliotecas.
import sys # Biblioteca para acessar módulos do sistema

# Se estiver executando no Google Colaboratory
# Retorna true ou false se estiver no Google Colaboratory
IN_COLAB = "google.colab" in sys.modules

Define o nome do diretório(pastas)

Aqui você define em quais pastas do drive você irá trabalhar.



# Diretório
DIRETORIO = "dados_saas"

# Diretório local para os arquivos pré-processados
DIRETORIO_LOCAL = "/content/" + DIRETORIO + "/"

# Diretório no google drive com os arquivos pré-processados
DIRETORIO_DRIVE = "/content/drive/MyDrive/Base_SAAS/" + DIRETORIO + "/" + BASE + "/"

Verifique se você está no diretório correto observando a pasta do drive.

Monta uma pasta de processamento local dentro do colab



# Importando as bibliotecas.
import os

# Cria o diretório para receber os arquivos Originais e Permutados
# Diretório a ser criado
dirbase = DIRETORIO_LOCAL[:-1]

if not os.path.exists(dirbase):  
    # Cria o diretório
    os.makedirs(dirbase)    
    logging.info("Diretório criado: {}".format(dirbase))
else:    
    logging.info("Diretório já existe: {}".format(dirbase))

Exporta um arquivo em pandas para o diretório local do colab



# Import das bibliotecas.
import pandas as pd

NOME_ARQUIVO_ORIGINAL = 'original.csv'

# Salva o arquivo original
df.to_csv(DIRETORIO_LOCAL + NOME_ARQUIVO_ORIGINAL, sep=";", index=False)

Copia do diretório local colab para o diretório do google drive



# Se estiver executando no Google Colaboratory
if IN_COLAB:
    # Copia o arquivo original   
    !cp "$DIRETORIO_LOCAL$NOME_ARQUIVO_ORIGINAL" "$DIRETORIO_DRIVE"

    logging.info("Terminei a cópia")

Acessa um arquivo CSV com o nome original.csv que está na pasta do diretório



# Nome do arquivo
NOME_ARQUIVO_FONTE = "fact_caged.csv"

# Se estiver executando no Google Colaboratory
if IN_COLAB:

  !cp "$DIRETORIO_DRIVE$NOME_ARQUIVO_FONTE" "$DIRETORIO_LOCAL"

  logging.info("Terminei a cópia!")

import pandas as pd

df = pd.read_csv(DIRETORIO_LOCAL + NOME_ARQUIVO_FONTE, sep=";")

df.head(10)

Zipa o arquivo e exporta



# Nome do arquivo
NOME_ARQUIVO_ORIGINAL_COMPACTADO = "original.zip"

!zip -o -q -j "$DIRETORIO_LOCAL$NOME_ARQUIVO_ORIGINAL_COMPACTADO" "$DIRETORIO_LOCAL$NOME_ARQUIVO_ORIGINAL"

# Se estiver executando no Google Colaboratory
if IN_COLAB:
    # Copia o arquivo original   
    !cp "$DIRETORIO_LOCAL$NOME_ARQUIVO_ORIGINAL_COMPACTADO" "$DIRETORIO_DRIVE"

    logging.info("Terminei a cópia")

Espero que te traga uma luz como acessar seus arquivos do Google Drive no Google Colab.

Abraços!

Análise Assintótica

Rita Carolina — Mon, 02 Jan 2023 18:28:39 +0000

A ordem de crescimento descrita neste artigo anterior descreve apenas a eficiencia da performance de algoritmos alternativos. O objetivo da análise de algoritmos é conseguir uma medida que não seja tão precisa, para calcular o tempo computacional de um algoritmo.

Isso não é uma tarefa fácil como vimos. A notação assintótica na complexidade de algoritmos é identificar classes de algoritmos que possuem comportamento similar.

O que é Notação Assintótica?

Para entender melhor as palavras eu venho buscando a etimologia, a origem e os significados das palavras.

Notação é o nome que se dá ao método de representar mensagens por meio de símbolos.
Assíntótica, próprio de assíntota, da linha que, numa curva plana, expressa uma distância infinita em relação ao ponto P.

As notações que usamos para descrever o tempo de execução assintótica de um algoritmo são definidas em termos de funções cujos domínios são o conjunto dos números naturais N = {O,1,2, ...). Tais notações são convenientes para descrever a função do tempo de execução do pior caso T(n), que em geral é definida sobre o tamanhos da entrada.

Em outras palavras, notação assintótica é uma representação simbólica por meio de funções do tempo de execução de um algoritmo.

Contudo, as vezes é conveniente abusar da notação assintótica de várias maneiras. Por exemplo, a notação é estendida com facilidade ao domínio dos números reais ou, de modo alternativo, limitado a um subconjunto dos números naturais. Porém, é importante entender o significado preciso da notação para que, quando houver um abuso em seu uso, ela não seja mal utilizada.

Toda vez que falarmos função neste artigo, estaremos nos referindo a uma função de equação matemática.

Notação Θ ou Notação Tetha

Digamos que se uma função f(n) está entre os valores c2 * g(n) e c1 * g(n) para duas constantes c1 e c2. Traduzindo, uma função qualquer está entre duas funções iguais multiplicadas por constantes diferentes. Essa função f(n) pertence ao grupo (g(n)).

Então diz-se que a função g(n) é um limite assintóticamente restrito para f(n). Formalmente falando em uma descrição matemática:

Ao representar esta equação em um gráfico matemático:

Figura 2 – Exemplo da aplicação da notação assintótica Θ.

Por força de representação, é comum considerar que f(n) = (g(n)) (lê-se “f de n é téta de g de n”) , que traduzindo, a função F de n é igual ao Tetha da função G de n.

Embora o correto seja f(n) (g(n)) que a função F pertence ao limite assintótico do Tetha da função G.

Exemplos de duas funções que se encaixam na condição f(n) (g(n)):

f(n) = 12n²-3n
g(n) = n²

Lembra como simplificamos a equação no artigo anterior apenas para o termo principal da fórmula? Aqui têm outro exemplo.

f(n) = 100n³-n² +3.5n - 17
g(n) = n³

Notação O ou Notação Big O

Se uma função f(n) possui como limite assintótico superior o valor g(n), então diz-se que f(n) pertence ao grupo O(g(n)). Também pode se dizer que g(n) é o limite assintótico superior para f(n). Formalmente falando em uma descrição matemática:

Exemplo da aplicação da notação assintótica O.

Também é preciso ter em mente que se f(n) (g(n)) , então a mesma função também pertence a (g(n)), ou seja f(n) O(g(n)) .

A notação O é usada sempre para informar qual é o pior caso da complexidade de um algoritmo.

Desse modo, quando se diz que “a complexidade de um algoritmo é O(n²) (lê se Big O de Ene ao Quadrado)” que o algoritmo demandará tempo de pior caso c*n² para uma entrada de tamanho n.

Exemplos de duas funções que se encaixam na condição f(n) O(g(n)):

f(n) = 14n²-n
g(n) = n² - 6n

Lembra como simplificamos a equação no artigo anterior apenas para o termo principal da fórmula? Aqui têm outro exemplo.

f(n) = 100n³-n² +3.5n - 17
g(n) = 2n+3n²

Notação Ω ou Notação Ômega

Se uma função f(n) possui como limite assintótico inferior o valor g(n), então diz-se que f(n) pertence ao grupo (g(n)). Também pode se dizer que g(n) é o limite assintótico inferior para f(n). Formalmente falando em uma descrição matemática:

Exemplo da aplicação da notação assintótica Ω.

Teorema é uma proposição a ser provada, ou que pode ser demonstrada por meio de um processo lógico. É importante para quem está cursando a matéria de algoritmos conheça esses teoremas, que podem ser usados para provar outros teoremas.

Para quaisquer funções f(n) e g(n), f(n) (g(n)) se f(n) O(g(n)) e f(n) (g(n))

Repare que essa é uma preposição lógica.

Notação o

Se uma função f(n) possui como limite assintótico não é justo a g(n), então diz-se que f(n) pertence ao grupo o(g(n)). Também pode se dizer que g(n) é o limite assintótico inferior para f(n). Formalmente falando em uma descrição matemática:

Notação ω

Propriedades das Notações

É necessário possuir algum conhecimento lógico e de equações matemáticas para entender as propriedades abaixo.

Transitividade

f(n) ∈ Θ(g(n)) e g(n) ∈ Θ(h(n)) implicam que f(n) ∈ Θ(h(n));

f(n) ∈ O(g(n)) e g(n) ∈ O(h(n)) implicam que f(n) ∈ O(h(n));

f(n) ∈ Ω(g(n)) e g(n) ∈ Ω(h(n)) implicam que f(n) ∈ Ω(h(n));

f(n) ∈ o(g(n)) e g(n) ∈ o(h(n)) implicam que f(n) ∈ o(h(n))

Reflexividade

f(n) ∈ Θ(f(n));

f(n) ∈ O(f(n));

f(n) ∈ Ω(f(n));

Simetria

f(n) ∈ Θ(g(n)) se e somente se g(n) ∈ Θ(f(n)).

Simetria de Transposição

f(n) ∈ O(g(n)) se e somente se se g(n) ∈ Ω(f(n));

f(n) ∈ o(g(n)) se e somente se se g(n) ∈ ω(f(n)).

Existe uma analogia dessa relação entre funções com as comparações entre os números reais a e b que te facilita a entender o limite das funções

f(n) ∈ O(g(n)) é como a ≤ b;

f(n) ∈ Ω(g(n)) é como a ≥ b;

f(n) ∈ Θ(g(n)) é como a=b;

f(n) ∈ o(g(n)) é como a<b;

f(n) ∈ ω(g(n)) é como a>b.

Na multiplicação por uma constante funciona-se a seguinte regra. Ignora-se o valor da constante.

Θ(c f(n)) = Θ(f(n));

99n² ∈ Θ(n²).

O maior grau de um polinômio é o que é utilizado para representar a notação assintótica

3n³ −5n² +100 ∈ Θ(n³);

6n^4 −20n² +100 ∈ Θ(n4);

0,8n +224 ∈ Θ(n).

Na ordem do termo dominante

2n +6n³ ∈ Θ(2n);

n! - 3n² ∈ Θ(n!);

n log n +3n² ∈ Θ(n²).

Análise de Algoritmos para Iniciantes

Rita Carolina — Sat, 15 Oct 2022 14:18:04 +0000

Analisar o tempo de execução de um algoritmo é outro fantasma que assombra programadores iniciantes. Pode me chamar de caça-fantasmas que hoje você vai terminar de ler este artigo e vai sentir um alívio por finalmente entender o que é análise de algoritmos e como isso funciona. Quando conhecemos nossos fantasmas eles já não nos assustam mais.

Este tipo de analise propõe prever recursos computacionais (o quanto de memória ou banda de internet) que o algoritmo precisa para ser executado. Computadores da vida real trabalham fundamentalmente (ou seja, na sua forma mais básica) com equações aritméticas (somar, subtrair, multiplicar, dividir, função piso e função teto), movimentação de dados (carregar, copiar e armazenar) e controle (condições if, chamadas de subrotina e retorna). Não se preocupe se você não entendeu algumas palavras, eventualmente elas farão sentido e você não precisa necessariamente sabê-las para realizar uma análise dessas.

Em geral o tempo de execução de um algoritmo cresce de acordo com o tamanho da sua entrada. Então uma forma tradicional (ou que é utilizada com frequência) é descrever o tempo de execução de um algoritmo como uma função do tamanho da sua entrada. Por exemplo.: f(x) = x² ou até Bhaskara.

Você achou que nunca ia usar as equações que aprendeu na escola né? Pois então. Para fazer isso precisamos definir os termos “tempo de execução” e “tamanho da entrada” com mais cuidado.

Tamanho da entrada

A melhor noção do tamanho da entrada depende do problema que está sendo estudado. Um algoritmo pode levar tempos de execução diferente dependendo de como os dados estão ordenados ou até de como são representados. Por exemplo, multiplicar dois números inteiros utiliza o espaço de dois números para a representação na memória, logo é necessário o espaço em memória para armazenar os números binários que descrevem estes dois números.

Já em outros casos, a entrada pode ser um grafo, que é uma estrutura que possui nós e arestas. A melhor forma de representar o tamanho da entrada de um grafo é justamente através da quantidade de nós e arestas que este grafo possui. Cada projeto possui uma indicação do tamanho da medida da entrada que está sendo usado.

Se você não entendeu ainda o conceito de memória e variável dê uma olhada no artigo anterior aqui (LINK).

Tempo de execução

O tempo de execução de um algoritmo a partir de um determinado número de entrada é simplesmente o número de passos executados. Isso acontece porque é importante definir bem o tempo de execução para que seja representada o mais INDEPENDENTE DA MÁQUINA possível. Então a notação (o jeito que é escrito) de uma constante que vamos chamar de C será Ci. Cada linha de instrução do algoritmo representará o tempo de execução.

Exercício opcional

Para cada função f(n) e tempo t na tabela a seguir, determine o maior tamanho n de um problema que pode ser resolvido no tempo t, supondo que o algoritmo para resolver o problema leve f(n) microssegundos.

Dica.: Substitua o valor de n equivalente em microsegundos dentro da função e observe o que acontece.

Analisando o Algoritmo

Para praticar esta tarefa de analisar o tempo de execução de um algoritmos, precisamos de um modelo de implementação. Tenha em mente que vamos identificar uma fórmula simplificada que representa o tempo de execução que mostra as características mais importantes de um algoritmo.

O algoritmo escolhido é um algoritmo muito usado para iniciantes: o Insertion Sort. A notação do algoritmo será representada em inglês e em pseudocódigo, que é a língua utilizada para representar algoritmos em todo o mundo. Na imagem 1 mostra o algoritmo, e eu vou explicar linha por linha.

Imagem 1: Algoritmo Insertion Sort escrito em pseudocódigo

Repare que a função é chamada insertion-sort(A). A letra A é uma variável que guarda o vetor que é recebido como argumento da função para ser ordenado.

Um loop for que percorre de uma variável j que inicia com o valor 2 armazenado. Cada interação o valor de j é alterado para o próximo número e isso ocorre até o tamanho do vetor A. Traduzindo em python:

1 for j in range(1, len(A)):

O início da função "do" significa "faça" neste contexto e está dentro do for. Executa uma sequencia de comandos enquanto o for executar. O comando é uma atribuição de um valor A[j] para a variável key. Traduzindo em python:

2        key = A[j]

Esta função define o valor de uma nova variável i em uma posição menor que a posição atual. O objetivo dessa linha é mover o valor chave em uma posição uma vez menor que a atual.

4        i = j - 1

O valor de uma nova variável i em uma posição menor que a posição atual. O objetivo dessa linha é mover o valor chave em uma posição uma vez menor que a atual.

5        while i >= 0 and A[i] > key:

O valor atual é substituido no valor posterior. Imagine uma régua que começa no 1, se você adicionar +1, você irá para a posição 2.

6            A[i + 1] = A[i]

O comando 7 é comum, que simplesmente subtrai 1 da variável i.

7            i = i - 1

Uma outra atribuição (ou substituição) do valor que estava na variável key para a variável i+1.

8        A[i + 1] = key

Aqui a implementação completa em python traduzindo o pseudocódigo acima.

  def InsertionSort(A):
1    for j in range(1, len(A)):
2        key = A[j]
3        # Insere o valor A[j] na sequência A[1, j-1]
4        i = j - 1
5        while i >= 0 and A[i] > key:
6            A[i + 1] = A[i]
7            i = i - 1
8        A[i + 1] = key
9    return A

Para testar você pode instalar o python, copiar o código e executar!

arr = [12, 11, 13, 5, 6]
InsertionSort(arr)

Um exemplo desenhado do algoritmo funcionando. A variável key é a representada em preto. As em cinza é a movimentação dentro do while.

É muito importante para entender o algoritmo que você observe o comportamento do algortimo em uma lista neste link. Para analisar o tempo de execução dele vamos montar uma tabela com o código em python. Você pode montar a tabela em seu caderno com qualquer algoritmo.

Cálculo do Tempo de Execução

Atenção que vamos entrar no campo da matemática. São contas simples que só precisam de um pouco de atenção. Para cada comando se define um custo ci onde i se refere a uma linha específica. A constante c serve para o custo computacional para executar aquela linha. Essa constante, mais tarde, pode ser substituida por um valor equivalente ao custo computacional. O tempo de execução é definido pelo número de instruções n. Lembre-se que o custo não interfere no que está escrito no código, e sim representa quantas vezes aquela linha é executada.

Agora repare nesta tabela que criamos, onde na primeira coluna insere-se a linha de código, na segunda o custo e na terceira o tempo de execução.

Como você deve ter percebido, a primeira linha executa n vezes com um custo c1. Lembra que n é o tamanho da entrada que vimos antes? Imagine o vetor A = [1,2,3,4,5], qual é o tamanho n desta entrada? Isso mesmo, 5 porque a quantidade de elementos do vetor é 5. Então o custo dessa linha seria:

Você deve estar se perguntando, por que nas linhas subsequentes começando da linha 2, o tempo é (n-1)? Repare que todos os próximos comandos estão dentro de um loop for. Isso significa que poderá executar todas as vezes menos a última vez que não entrar no loop.

No segundo while na linha 5 vemos um somatório. Isso acontece porque é um loop dentro de um loop. Essa situação incomum precisa ser representada por algum cálculo matemático que condiza com a situação real. O somatório é a solução mais prática. A variável t representa o mesmo tempo de execução de n, mas repare a quantidade de vezes que ela é somada, para perceber você precisa conhecer somatório ou pode testar expandir a equação do somatório para n = 5 você irá perceber. Faça isso no seu caderno, vai ser divertido.

Em resumo, para definir o tempo de execução de cada linha, é preciso imaginar quantas vezes ela será executada e usar a equação necessária para representa-la. Dica: Normalmente nunca passa de um simples somatório.

Após definir qual o valor do tempo de execução, multiplicamos cada constante pelo seu tempo de execução, igual fizemos na primeira linha.

Note que esta é uma equação simples. Caso você não esteja entendendo, recomendo fortemente que você pesquise como resolver equações e somatórios. A análise pode ser feita entre o melhor caso, pior caso e caso médio.

Melhor caso

Imagine a situação onde o array já está ordenado. A = [1,2,3,4,5] Este é o melhor caso. Ao invés de usarmos de fato o somatório, caso você realize as substituições realizando um teste de mesa e calcular o tempo de execução vai ser possível perceber a substituição realizada abaixo.

Esse tempo de execução pode ser expresso como T(n) = an − b (eu substitui todas as constantes por uma só, coisa da matemática) para constantes a e b que dependem dos custos da declaração ci é, portanto, uma função linear de n.

Pior caso

Se o array estiver ordenado ao contrário, ou seja, de forma decrescente, este é o pior caso do tempo de execução. Com isso podemos realizar a substituição dos somatórios por uma progressão aritmética de soma finita. Quando um algoritmo contém uma construção de controle iterativa, como um loop while ou for, seu tempo de execução pode ser expresso como a soma dos tempos gastos em cada execução do corpo do loop. Avaliar essa soma produziu equações no tempo de execução do pior caso do algoritmo.

Substituindo os somatórios por essas progressões na nossa equação principal.

Resolvendo temos que o pior caso pode ser expresa em uma equação de crescimento quadrático em função de n.

T(n) = an²+bn+c

Análise do melhor e pior caso

O tempo de execução do pior caso de um algoritmo é um limite superior no tempo de execução para qualquer entrada. Saber disso nos dá uma garantia de que o algoritmo não demorará mais. Não precisamos fazer suposições sobre o tempo de execução e esperar que nunca fique muito pior.

Para alguns algoritmos, o pior caso ocorre com bastante frequência. Por exemplo, ao pesquisar em um banco de dados uma determinada informação, o pior caso do algoritmo de pesquisa geralmente ocorrerá quando a informação não estiver presente no banco de dados. Em alguns aplicativos de busca, as buscas por informações ausentes podem ser frequentes.

O “caso médio” é quase tão ruim quanto o pior caso. Se calcularmos o tempo de execução do caso médio resultante, ele será uma função quadrática do tamanho da entrada, assim como o tempo de execução do pior caso.

Conclusão

Usamos algumas abstrações simplificadoras para facilitar nossa análise do procedimento INSERTION-SORT. Primeiro, ignoramos o custo real de cada declaração, usando as constantes ci para representar esses custos e ainda simplificamos pelas variáveis "a" e "b". Assim, ignoramos não apenas os custos reais da declaração, mas também os custos abstratos ci.

Faremos agora mais uma abstração simplificadora. É a taxa de crescimento, ou ordem de crescimento, do tempo de execução que realmente nos interessa. Portanto, consideramos apenas o termo principal de uma fórmula (por exemplo, an²), uma vez que os termos de ordem inferior são relativamente insignificantes para n grande. Também ignoramos o coeficiente constante do termo principal, uma vez que os fatores constantes são menos significativos do que a taxa de crescimento na determinação da eficiência computacional para grandes entradas.

Assim, escrevemos que o algoritmo de inserção tem como pior caso o tempo de execução Θ(n²). Isso é chamado de notação assintótica que veremos no próximo artigo.

Como corrigir ícones font-awesome desaparecidos ou problema com fontes Avada

Rita Carolina — Fri, 14 Oct 2022 11:55:29 +0000

Cole essas linhas de comando na ordem

Autoriza edição do arquivo de configuração
sudo chown bitnami:daemon /opt/bitnami/apache2/conf/vhosts/htaccess/wordpress-htaccess.conf
Autoriza edição do arquivo de configuração
sudo chmod g+w /opt/bitnami/apache2/conf/vhosts/htaccess/wordpress-htaccess.conf
Abre o arquivo para edição
sudo nano /opt/bitnami/apache2/conf/vhosts/htaccess/wordpress-htaccess.conf
Cole o conteúdo abaixo no final do arquivo

# Apache config
<FilesMatch ".(eot|ttf|otf|woff)">
Header set Access-Control-Allow-Origin "*"
</FilesMatch>

Aperte ctrl+s para salvar
Aperte ctrl+x para fechar
Reinicie o servidor apache

sudo /opt/bitnami/ctlscript.sh restart apache

Se o problema continuar, O cache Fusion deve ser o culpado.

Desative o CSS & JS feature no Avada > Theme Options > Advanced > Dynamic CSS & JS, e tente resetar o Fusion cache:

O que é dark data?

Rita Carolina — Thu, 06 Oct 2022 12:32:50 +0000

Dark data é o conceito que define uma grande quantidade de dados armazenados, mas intocáveis por organizações. São dados que simplesmente não são utilizados. Por exemplo.: Imagens da câmera que nunca mais são vistas ou dados de sensores de aparelhos conectados na Internet das Coisas. São dados que foram coletados por algum motivo, mas não servem para mais nenhum outro propósito. Como gravações armazenadas apenas para registro ou segurança.

Armazenar dark data aumenta consideravelmente os custos a longo prazo. Estes dados normalmente são inacessíveis por banco de dados relacionais tradicionais, mas possuem um valor, por isso continuam sendo armazenados mesmo não tendo um retorno financeiro previsto. Tipicamente isto acontece porque os dados são armazenados em um formato que não é acessível no momento e as organizações preferem continuar armazenando na esperança de usá-los no futuro.

Eu vejo que é muito interessante saber que existem dados que não são usados pelas organizações, mas que ao mesmo tempo é um desperdício não usar esses dados para realizar análises que valorizem o negócio, principalmente com o avanço da tecnologia. Sinto que é inevitável esses dados existirem. Mas que no futuro teremos recursos capazes de analisa-los.

Eu mesma tenho muitas imagens na câmera, e dados armazenados no google drive de anos anteriores que provavelmente eu nunca mais vá usá-los.

Fonte: https://developer.ibm.com/articles/ba-data-becomes-knowledge-3/

Entenda o que é um algoritmo de uma vez por todas

Rita Carolina — Fri, 16 Sep 2022 10:46:44 +0000

Algoritmo parece um bicho de sete cabeças, mas só enquanto a gente não conhece o conteúdo ou escuta a palavra pela primeira vez. Quem não é da área de tecnologia até treme quando pensa em programação. Muitos até acham que você precisa ser especial pra conseguir se tornar um programador. Eu digo uma coisa: BA LE LA. Qualquer um pode aprender a programar, porém eu tenho que dizer outra coisa, é fundamental querer muito ou gostar mais do que qualquer outra coisa, porque quando o negócio fica feio, é o querer que vai te fazer seguir em frente.

Trouxe aqui uma Introdução a Algoritmos para você que está começando entender o que é esse mundo que está pagando tão bem. Você vai entender o que esse povo que passa horas em frente ao computador faz e vai perceber que não é aquele bicho de sete cabeças. Ele tem uma cabeça só e eu vou te dar as ferramentas necessárias para enfrenta-lo.

Antes de tudo você precisa entender como o computador funciona. Eu não vou contar a história da programação aqui, mas você pode entender melhor neste vídeo. O que você precisa saber agora é: O computador é um emaranhado de números zeros e uns. Eu sei, ir com calma. Mas acompanha o raciocínio.

Em algum momento da humanidade alguém descobriu a eletricidade e em outro momento descobriram como aprisionar pequenos impulsos elétricos (sim, parecido com os do seu cérebro), logo tiveram que INVENTAR uma lógica, que hoje em dia chamam de lógica de programação. Isso mesmo! Tiraram da cartola do mágico uma nova língua pra que pudessem usar esses bits aprisionados conhecidos como números binários. Esses bits são representados por números 0s e 1s apenas, e a lógica de programação trabalha em torno desses dois números!

Você já notou que a informação é invisível? Esses bits armazenam informações ou pelo menos, representação de informações. Chamamos de estruturas de dados o jeito de organizar e armazenar essas informações.

Não demorou muito, a coisa evoluiu e ficou mais complexa. Circuitos e interruptores foram criados com essas combinações da lógicas, tanto que, os primeiros computadores nem tinham interface visual ou interface gráfica, que é a tela pela qual você lê este artigo. Quem revolucionou o mercado dessas máquinas foi nosso amigo conhecido da maçã. Ele popularizou o computador para uso pessoal, onde antes era usado apenas para fins militares.

Logo, como que aconteceu de circuitos e máquinas gigantes se transformar em um computador pessoal e ir pra interface gráfica? Falta alguma coisa ai nesse meio. Essa é a linguagem de programação, ela é necessária para traduzir impulsos elétricos mais básicos para comandos complexos. Isso acontece porque alguém programou instruções básicas no hardware (a parte que você chuta). Esses comandos são chamados de linguagem de máquina.

Uma definição formal de algoritmos, de acordo com o Cormen (um cara que escreveu um ótimo livro sobre algoritmos) é “qualquer procedimento computacional bem definido que toma algum valor ou conjunto de valores como entrada e produz algum valor ou conjunto de valores como saída”. Você pode imaginar como uma receita de bolo, que são um conjunto de instruções bem definidas que não são ambíguas, ou seja, são exatas. Você pode afirmar com toda certeza (por enquanto) que o computador é fundamentalmente burro, pois é simplismente um conjunto de combinações lógicas que responde a programação por algum ser humano.

Um algoritmo necessariamente precisa resolver algum problema computacional. Ele não pode ser ambíguo, ou seja, necessariamente não se pode dar um comando com duplo sentido.

Algoritmos é o fundamento para programar com alguma linguagem. Conhecer como os algoritmos funcionam vai te permitir com facilidade aprender uma nova linguagem de programação.

Se você leu com atenção, entendeu bem o que é algoritmos e já pode seguir com seus estudos! Sentiu falta de algo? Joga nos comentários.

O que é Big Data?

Rita Carolina — Thu, 15 Sep 2022 18:25:13 +0000

Big Data é um conjunto de dados ou dataset grande demais para um banco de dados convencional e que também pode ser definida como um conjunto de dados que precisa ser processado e é gerado em grande volume, velocidade e variedade. Esses dados são usados em processos de tomada de decisão em organizações afim de otimizar processos ou recursos. Esse é um conceito que se popularizou em 2008 com a ascenção das redes sociais.

Big data pode ser gerada por máquinas, humanos e organizações. Máquinas podem gerar uma quantidade enorme de dados com seus sensores, cameras, satélites e rádios. Uma caraterística popular em dados gerados por máquinas é sua necessidade de processamento em tempo real para otimizar a tomada de decisão. Por exemplo um avião gera 2.5 bilhões de terabyte por ano através de seus sensores instalados nos motores.

Humanos podem gerar toneladas de dados através das mídias sociais, subindo suas fotos, postando atualização de status e subindo vídeos. Uma caraterística comum de dados gerados por humanos é que em sua maioria são desestruturados. Já os dados que são gerados por organizações geralmente são informações altamente confiáveis, bem definidas e estruturados. Podem ser geradas por sistemas de gestão como um ERP, produzindo dados como registros e transações.

Fonte: https://www.iosrjournals.org/iosr-jce/papers/conf.15013/Volume%202/1.%2001-05.pdf?id=7556

Problemas modernos: Big Data - Um resumo do New York Times

Rita Carolina — Sun, 11 Sep 2022 11:12:07 +0000

No artigo do New York Times os autores abordam nove problemas que notaram no conceito de Big Data. Eles explicam que Big Data combina o poder da computação moderna com o mar de dados que existe por aí.

A primeira coisa que o artigo denota é que apesar de a big data ser ótima em detectar correlações, nunca nos diz quais correlações são significativas. Em segundo os autores escrevem que big data pode trabalhar bem junto com investigação científica, mas raramente obtém sucesso sozinha, precisa agregar uma base de entendimento em física e bioquímica. Em terceiro o artigo mostra que podemos brincar com diversas ferramentas baseada em grande quantidade de dados, mas não podemos prever a ação humana sobre ela. Por exemplo na correção de atividades de classe, quando os estudantes entendem qual é o padrão de correção, eles começam a escrever palavras obscuras ao invés de uma escrita clara e coerente, buscando apenas a nota, e não o aprendizado.

Em quarto, os autores especificam que um sistema de big data pode ser menos robusto do que parece, por exemplo o relatório de tendência de gripe inicialmente foi bem sucedido no início, mas ao longo dos anos passou a falhar com projeções muito ruins. Isso aconteceu devido a mudança não identificada nos padrões de identificação da doença ao longo do tempo. A quinta preocupação dos autores se refere ao efeito da "camara de eco”, podendo criar um efeito de loop vicioso quando a fonte dos dados produz a si mesma, por exemplo artigos da Wikipedia que foram escritos pelo google tradutor. Se houvesse um erro no google tradutor, além de afetar o conhecimento da biblioteca, afetaria também o google tradutor, que usa a Wiki de fonte, reforçando o erro.

Em sexto lugar, o risco de amplificar erros é trazido, por exemplo, o de correlações em excesso. Existe um risco aleatório de encontrar correlações que parecem significantes mas não são, isso pode acontecer se você procurar muitas vezes por correlações em duas variáveis. O sétimo problema que os autores vêem é que big data tenta disponibilizar soluções que parecem científicas para perguntas imprecisas. Ela traz exemplos sobre a tentativa de decidir quais figuras históricas são mais relevantes, mas os resultados foram vagos e errôneos. Em último lugar os autores citam o problema dos “trigrams”, que são sequências de palavras em linha que são muito usadas em programas de tratamento de texto, entretanto nenhuma base de dados nunca será grande o suficiente para incluir todos os trigrams que as pessoas talvez usem, por causa da renovação contínua da língua.

O problema que os autores quase esquecem de adicionar é o hype do conceito big data! Eles concluem dizendo que big data está pra ficar, mas precisa ser usada como a ferramenta que é.

Além destes problemas existem muitos outros desafios que nos instigam a continuar trabalhando com big data. Por exemplo, a falta de um consenso bem definido do que é big data, permite uma ampla interpretação. Isso permite que qualquer um que possua uma grande quantidade de dados chame seu ecossistema de big data. Não que não seja, mas uma definição bem delineada permite que possamos compreender bem o que estamos tratando. É compreensível que isso aconteça visto que é uma tecnologia emergente que ainda está em desenvolvimento, logo menos ela terá uma forma bem definida e teremos a capacidade de dizer o que é ou não big data.

Outro problema que assombra o universo de big data é a falta de profissionais qualificados. Esses profissionais podem incluir engenheiros de dados, analista de dados e cientista de dados. Isso acontece porque a tecnologia evoluiu muito rápido, mas a quantidade de profissionais qualificados não cresceu na mesma proporção. Uma solução é contratar pessoas que estão iniciando na área e oferecer o treinamento devido e recompensas.

O último problema que eu observo e que também é uma caraterística no universo de Big Data é a falta de padronização nos tipos de dados. Existe uma quantidade enorme de informações por todo lugar, mas cada um no seu formato apropriado, sendo necessário uma mão de obra qualificada para tratar e padronizar a fim de realizar as análises necessárias para o negócio.

Concluindo, Big Data é uma tecnologia promissora que é fundamental para esse novo mundo dinâmico em constante mutação. Eu percebo que os infortúnios que a área de estudo vêm passando é temporário e acontecem majoritariamente porque é um estado da arte que se popularizou. Conforme mais atenção e dinheiro é investido para essa tecnologia evoluir, mais esses problemas serão resolvidos.

Marcus, G. and Davis, E., 2014. Eight (no, nine!) problems with big data. The New York Times, 6(04), p.2014.