DEV Community: Adriel Henrique

Kasparov X Deep Blue - Uma Abordagem Computacional

Adriel Henrique — Sat, 25 Jul 2026 18:33:04 +0000

Em 1997, houve um confronto que tem uma importância grande para a humanidade, longe dos campos de batalha e dos discursos políticos, confronto onde um supercomputador enfrentava aquele que até o momento era considerado por muitos como o maior enxadrista da história, de um lado um computador de milhões de dólares e do outro uma mente genial. Kasparov contra Deep Blue além de ser um marco na história da computação também o era para a humanidade, pois ao seu desfecho o maior enxadrista do mundo já não era humano.

De um lado do ringue, nascido na antiga União Soviética, se tornou campeão mundial aos 22 anos – até o momento era o mais jovem da história – ao vencer, em um confronto marcado por questões políticas, o também soviético Anatholy Karpov, conhecido por seu estilo posicional e por ser um grande estrategista. Kasparov que manteve seu título por quase 20 anos, conhecido por sua grande preparação de aberturas(formas de desenvolver as primeiras jogadas) e um estilo de jogo agressivo que buscava a “iniciativa”, que é quando após fazer um lance obriga o outro jogador responder e colocando-o na defensiva.

Do outro, um supercomputador de milhões de dólares, criação do cientista da computação Feng-hsiung Hsu, que durante seu doutorado nos Estados Unidos passou a estudar engines de xadrez — programas especializados em jogar xadrez -. Após ingressar na IBM, dedicou-se ao projeto de construir uma máquina capaz de derrotar o campeão mundial

O primeiro confronto ocorreu em 1996 e terminou com uma vitória convincente de Kasparov. O campeão aceitou uma revanche no ano seguinte, e é justamente esse segundo confronto — em especial a primeira das seis partidas — que será analisado neste texto.

A Matemática por trás das Engines:

O Xadrez é considerado um jogo computacionalmente intratável e durante muito tempo se acreditou que computadores não poderiam jogar o jogo. Mas o que isso quer dizer? Para cada lance feito, o número de possibilidades de movimento cresce exponencialmente, chegando ao número de Shannon que tem um valor inimaginavelmente grande de 10^120 lances.

Essa crença refutada pela história, vinha da ideia da “explosão de combinatória” que é quando o número de combinações de um experimento matemático cresce de forma muito rápida e da ideia que um computador teria que “avaliar” todos os lances. Diante dessa dificuldade surgiu uma ideia: Os computadores deveriam em vez de avaliar todos os lances, procurar apenas aqueles que faziam sentido.

Para isso, os engenheiros desenvolveram uma função de avaliação capaz de atribuir uma nota a cada posição do tabuleiro. Essa função era calibrada com base no conhecimento de mestres e na análise de milhares de partidas de alto nível, utilizando métodos estatísticos para ajustar a importância de fatores como material, segurança do rei, estrutura de peões e mobilidade.

Assim, o computador conseguia estimar quais posições eram mais favoráveis e direcionar sua busca para as variantes mais promissoras.
Em resumo, ela poderia encontrar os lances mais promissores, ao “atribuir notas” à lances e posições, fazendo ela “podar” linhas ruins ou perdedoras.(guarde esta informação)

Tática e Estratégia

Como um jogo estratégia, é esperado que o xadrez se baseie em planos. Planos de longo prazo são chamados de estratégia e os de curto prazo que miram uma vantagem imediata são chamadas de tática.

No caso o “longo prazo”, seria as desenvolver as peças, posicionando-as da forma mais “eficiente possível”, as tornando o mais ativas:
As torres atuam melhor quando trabalham juntas em colunas abertas;
Os bispos atuam melhor em diagonais longas, posições abertas e quando temos ambos no tabuleiro, de forma que cada um cubra as casas escuras ou brancas;
Os cavalos atuam melhor em posições fechadas pois podem “saltar” sobre as peças e quando apoiadas por um peão, que é chamado de base de operações;
A Dama é a peça mais poderosa de todas e é o coração do ataque, ela trabalha muito bem em conjunto com todas as outras peças;
O rei vale o jogo e só deve ser utilizado em finais;
E o peão? É a alma do jogo! Os peões limitam as ações das peças inimigas e podem definir o vencedor de uma partida.

Peças bem posicionadas ou ter peças a mais criam uma vantagem, no caso posicional ou material.

A Primeira Partida

Essa partida à primeira vista pode parecer estranha. Mesmo conduzindo as peças brancas, Kasparov joga de forma encolhida e defensiva, evitando complicações táticas imediatas e conduzindo o jogo para uma posição fechada, evitando o contato, muito diferente de seu estilo naturalmente agressivo. Essa escolha fazia parte de uma estratégia conhecida como tática anti-computacional. Na década de 1990, programas como o Deep Blue eram extraordinários em posições táticas, nas quais algoritmos de força bruta e o cálculo profundo encontravam rapidamente as melhores sequências de lances. Em posições fechadas, entretanto, os planos estratégicos de longo prazo tinham maior importância, exigindo que a função de avaliação do computador captasse nuances posicionais mais difíceis de quantificar. Além disso, ao escolher uma variante pouco comum, Kasparov buscava retirar o Deep Blue de seu livro de aberturas logo nas primeiras jogadas, obrigando-o a depender apenas de seus algoritmos de busca e avaliação.

Podemos pensar na “tática anti-computacional” de Kasparov como forçar o computador a jogar posições onde ele tinha mais dificuldade, posições fechadas e com poucas partidas de referência que faziam o Deep Blue sair de seu livro de aberturas mais cedo. E neste cenário, algoritmos de força bruta e algoritmos de busca perdiam eficiência devido à explosão de combinatória. Nesse cenário se sobressai as estratégias de longuíssimo prazo, aos poucos construir uma posição superior, acumulando pequenas vantagens e forçando o computador ao erro até o derrotar.

Após muitos lances sem contato entre as peças:

Kasparov permite que o computador tome sua torre com o bispo o que parece uma loucura: mesmo que tome o bispo de casas negras do Deep Blue, a torre é muito superior ao bispo. Isso era parte do plano. Computadores tem dificuldade de avaliar vantagens posicionais, sua função de avaliação tinha maior dificuldade para mensurar a compensação estratégica obtida por Kasparov, especialmente o avanço inevitável dos peões passados que viria logo em seguida, entrando em uma posição perdida.

Agora Kasparov tem dois peões passados e conectados(um peão apoia o outro), que inevitavelmente vão chegar ao fim do tabuleiro sendo coroados para uma dama e vencendo o jogo. Poucos lances depois, os engenheiros do Deep Blue jogaram a toalha e admitiram a derrota.

Apesar dessa vitória, Kasparov teve que trocar sua estratégia de jogo, pois era perigoso demais jogar em um estilo que não era o dele, esse estilo não era só “anti-computacional” mas também “anti-Kasparov”.
Entretanto, a vitória de Kasparov seria apenas temporária. O Deep Blue empatou a segunda partida e, ao final do confronto, venceu o match por 3½ a 2½. Pela primeira vez, um campeão mundial em atividade era derrotado por um computador em condições oficiais, um marco na história da computação e da inteligência artificial.

Claude resolve problema em aberto e choca Donald Knuth

Adriel Henrique — Tue, 24 Mar 2026 21:09:37 +0000

Terence Tao - Para muitos um dos maiores matematicos vivos - acreditva que em alguns anos teriamos a IA sendo uma co-autora confiavel para artigos na área de exatas. Contrariando o que Tao acreditava , isso acabou de acontecer, a IA Claude pode resolver um problema de grafos que estava em aberto. Isso ocorreu em um novo trabalho publicado por Donald Knuth, um dos maiores nomes da ciência da computação e que também é um grande "ex-cético" da capacidade da IA, no auge de seus 88 anos estava trabalhando em um problema que o assombrava a semanas para sua lendária coleção de livros sobre programação(sim, Knuth ainda trabalha no "Art of Computer Programming"), quando houve um resultado inesperado, a IA Claude Opus pode resolver um problema de pesquisa em aberto.
Tentando a semanas resolver um problema de grafos e combinatória, Knuth solicitou ajuda a seu amigo Filip Stappers, que acabou jogando esse problema para o Claude, que tentou uma série de estratégias para tentar atacar o problema, após 25 abordagens percebeu que para encontrar uma solução "geral" para o problema informado deveria usar matemática pura, onde após uma série de erros pode encontrar mesmo que de maneira muito incompleta algumas soluções que permitiam uma generalização, que Knuth tratou de desenvolver e que de fato resolvia o problema. Apesar do grande sucesso do Claude, por vezes ele chegou a "enroscar" sem conseguir executar os próprios progamas que escrevia além de não ter conseguido de fato elaborar a generalização.
Para finalizar o paper "Claude Cycles", Knuth fez uma piada que de fato nos deixa bastante reflexivos: "Acho que o espírito de Claude Shannon provavelmente se orgulha de saber que seu nome agora está sendo associado a tais avanços. Parabéns ao Claude!".
Esse acontecimento é algo incrível. Ainda me lembro de alguns professores dizendo que o ChatGPT errava muitas coisas de matemática básica. Ou ainda, há algum tempo, ao colocar um problema da Olimpíada Internacional de Matemática — que levei um tempo considerável para resolver —, nenhuma IA que testei foi capaz de resolvê-lo.
o problema em questão:

IMO - 1964. Prove que, para a>b² ,ocorre a seguinte identidade: a - b a + b a - b ... = a - \frac{3 b ^{2}}{4} - \frac{b}{2}

Apesar de ser uma questão bastante complexa, ela segue um caminho relativamente conhecido; o problema real é a fatoração de um polinômio de grau 4 que surge ao desenvolver a expressão. Em outra situação, cheguei a testar alguns problemas algebricamente bem pesados do livro Higher Algebra, de Hall and Knight — conhecido por ter exercícios de altíssimo nível —, onde o DeepSeek apresentou dificuldades, “enroscando” ou não conseguindo resolver alguns deles.
Todavia, os problemas citados são simplesmente triviais perto do que Knuth e Filip Stappers pediram ao Claude para resolver. De fato, isso pode ser um avanço considerável no uso de IA em nível de pesquisa. De fato, parabéns ao Claude!

Entendendo Ponteiros

Adriel Henrique — Fri, 12 Jul 2024 14:08:50 +0000

Em graduações da área de tecnologia, existem conceitos e matérias que geralmente assustam os alunos, alguns dos principais exemplos são matérias relacionadas a Programação Orientada a Objetos e Cálculo, outro exemplo são algumas noções mais abstratas tal como ponteiros, principalmente em C, tema deste artigo.
Diferentemente de nós, os computadores não conhecem uma determinada informação por um “rótulo” ou “nome”, e sim pelo endereço onde este dado está alocado na memória. Podemos pensar na memória como um conjunto de “células” que contém um número de bits que armazenam 0 ou 1 e que cada célula está associada a um determinado endereço onde armazena alguma informação para que os programas executados pela máquina possam acessar estes dados e os manipular.
Tendo em vista que para um programa poder usar um dado ele precisa saber de seu endereço na memória, podemos conceber o conceito de ponteiro. O ponteiro é uma variável que “aponta” para algum outro dado, é como se fosse um espaço na memória destinado a guardar o endereço de outra variável ou informação para que esta possa ser manipulada.
Mas agora vem a pergunta, qual a utilidade de um ponteiro? O ponteiro permite algumas operações mais complexas envolvendo a memória, tal como alocação dinâmica com Malloc ou a criação de estruturas de dados mais complexas, etc. Além disso, há alguns detalhes que não são tão facilmente percebidas pelos estudantes em um primeiro momento, tal como o fato de o nome de um vetor ser um ponteiro. Isto mesmo, um vetor nada mais é que um “ponteiro fixo” que aponta para uma determinada posição na memória e que nós usamos o índice para manipular de acordo com a necessidade.
Outra utilidade é a manipulação de dados por referência, por exemplo: passar uma matriz como parâmetro para outra função, permitindo que a matriz original seja modificada ao invés do valor ou objeto passado ser apenas uma cópia, algo que por exemplo ocorre no Javascript onde não há conceito de ponteiro (ao menos não explicitamente), por exemplo:

#include <stdio.h>

int vet [5] ={10,20,3,4};

void somadez(int * ref){
    for(int i=0;i<5;i++)
        ref[i]+=10;
}

int main () {
    somadez(vet);
    for(int i=0;i<5;i++)
        printf("%i\n",vet[i]);

    return 0;
}

saída:
20
30
13
14

note que quem foi alterado foi o vetor original

Outra utilidade não tão evidente de ponteiros, desta vez para linguagens orientadas a objeto, onde podemos, por exemplo, criar objetos dinâmicos e facilitar o trabalho com herança e polimorfismo.
Temos esse exemplo a baixo com C++:

#include <iostream>

using namespace std;

class Animal{
public:
    virtual void som();
};

class Cachorro : public Animal{
public:
    void som(){
        cout << "auau";
    }
};

int main () {
    Animal * ClasseBase;
    Cachorro ClasseFilha;

    ClasseBase = &ClasseFilha;
    ClasseBase->som();
    //neste caso podemos usar o ponteiro para acessar métodos e atributos de uma classe derivada.
    return 0;
}

Introdução ao Laravel

Adriel Henrique — Fri, 22 Dec 2023 06:09:10 +0000

O Laravel é um framework PHP de sintaxe elegante que fornece uma série de recursos para a construção de aplicações web padrão MVC ,possuindo uma vasta documentação e comunidade é um dos maiores frameworks para trabalhar com web da atualidade.
Para construir um projeto é necessário ter o composer instalado localmente e executar o seguinte comando:

composer create-project laravel/laravel<nome do projeto>

Após a execução do comando, será criado um diretório raiz do projeto e dentro dele terá uma série de diretórios que contem arquivos que servem para exercer certas funções em nossa aplicação, neste momento os diretórios que interessam são o “App” e “Routes”, o primeiro é necessário para definir os métodos e a maioria das funcionalidades do nosso aplicativo, sendo este o coração do projeto, ao qual não daremos tanto foco em um primeiro momento. O segundo diz respeito a organização de nossas rotas e o direcionamento de cada requisição.
Dando continuídade a explicação da pasta Route, dentro dela temos os arquivos: web.php, api.php, channels.php e console.php.
Geralmente, começamos definindo as rotas no “web.php” que são aquelas rotas que devem ser acessadas pelo navegador usando a url, para definir uma rota podemos fazer assim:

Route::get('/', function () {
return view('HelloWorld');
});

Este metodo, quando acessado a rota ‘/’, retorna um documento blade(Blade é uma ferramenta inclusa no laravel que fornece uma maneira de gerar e renderizar arquivos html) chamado “HelloWorld.blade.php” na pasta ‘/resoures/view’.
Outra ferramenta muito útil para trabalhar com Laravel é o Artisan que é uma interface em linha de comando que serve para agilizar o processo de desenvolvimento.
Podemos usar o Artisan para gerar um controller:

php artisan make:controller <nome do controller>

Controllers servem para gerenciar requisições http enviadas para determinadas rotas e poder adicionar uma lógica a estas.
Por fim vamos construir uma aplicação que pegue um parametro, chame um controller que através de um metodo retorne uma view
no web.php:

use App\Http\Controllers\exemplo;

Route::get('/{nome}', [exemplo::class, 'index']);

o 'use' indica a localização do arquivo do controller, nossa rota tem o parametro "nome" e no entre as colchetes esta a chamada do método index do controller "exemplo".

php artisan make:controller exemplo

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class exemplo extends Controller
{
    public function index(string $nome){
        return view('HelloWorld', ['nome' => $nome]);
    }
}

O Método index retorna a view "Hello World" passando para ela o parametro nome

<div>
    <h1>Hello, {{ $nome }}</h1>
</div>

entre as chaves esta o parametro que repassamos à view, o resultado deve ser assim quando acessarmos "http://127.0.0.1:8000/dev":

Resolvendo o Exercise Tracker - Free-code-camp

Adriel Henrique — Thu, 15 Jun 2023 19:04:47 +0000

A algum tempo fiz a certificação de Back-end da free-code camp,a maioria dos projetos propostos são no geral bem simples, no entanto, houve um que o nível de complexidade é mais elevado, que é o projeto de “exercise tracker”, neste artigo vou explicar como acabei resolvendo ele.

Para este artigo vou usar algumas ferramentas:

O repositório oficial do freecode camp do projeto.
Postman para trabalhar com a API

Além de alguns conhecimentos prévios, como:

Algumas noções de requições HTTP/REST.
Express, Mongoose e Atlas DB

O projeto quando importado do Github ou do Replit tem apenas as funções básicas do express:

const express = require('express')
const app = express()
const cors = require('cors')
require('dotenv').config()

Devemos adicionar as dependências do projeto tais como o Mongoose, para que funcione como nosso banco de dados NoSQL e o Body-parser para que possamos trabalhar com nossas requisições.

const express = require('express')
const app = express()
const cors = require('cors')
require('dotenv').config()
const mongoose = require('mongoose');
const bodyParser = require('body-parser');

app.use(bodyParser.urlencoded({ extended: true }))
app.use(bodyParser.json());

Indo para o html:

     <form action="/api/users" method="post">
        <h3>Create a New User</h3>
        <p><code>POST /api/users</code></p>
        <input id="username" type="text" name="username" placeholder="username" />
        <input type="submit" value="Submit" />
      </form>
      <form id="exercise-form" method="post">
        <h3>Add exercises</h3>
        <p><code>POST /api/users/:_id/exercises</code></p>
        <input id="uid" type="text" name="_id" placeholder=":_id" />
        <input id="desc" type="text" name="description" placeholder="description*" />
        <input id="dur" type="text" name="duration" placeholder="duration* (mins.)" />
        <input id="date" type="text" name="date" placeholder="date (yyyy-mm-dd)" />
        <input type="submit" value="Submit" />
      </form>

    <script>
      const exerciseForm = document.getElementById("exercise-form");

      exerciseForm.addEventListener("submit", () => {
        const userId = document.getElementById("uid").value;
        exerciseForm.action = `/api/users/${userId}/exercises`;

        exerciseForm.submit();
      });
    </script>

Análisando o html vemos que este possui dois formulários que chamam rotas diferentes uma chama a rota ‘/api/users/’ com uma requisição do tipo POST e a outra ‘api/users/:_id/exercises’.

Primeiramente,após definirmos as variaveis de ambiente e fazer a conexão com o AtlasDB devemos criar os Schemas e Modelos que usaremos:

async function main() {
  await mongoose.connect(mySecret);
}
//-----------
const userSchema = mongoose.Schema({
  username: String,
  _id: String
});
const exerciseSchema = mongoose.Schema({
  duser: String,
  description:{
    type: String,
    required: true
  },
  duration:{
      type: Number,
      required: true
  },
  date: Date
});

var User = mongoose.model('user',userSchema);
var exercise = mongoose.model('exercise',exerciseSchema);

No primeiro requisito deve-se utilizando um nome de usuário fornecido no formulário 'Create a New User' para um usuário e devolva uma resposta em JSON com o nome do usuário e seu id

app.post('/api/users',async function(req,res){
  const user = req.body.username;
  try{
    const username = await User.findOne({username: user});
    if(username == null){
      let newId = new mongoose.mongo.ObjectId();
      const newUser = new User({username: req.body.username, _id: newId});
      await newUser.save();
      res.json({'username':newUser.username,'_id': newUser._id});
    }else{
      res.json({'username':username.username,'_id': username._id});
    }

  }catch(err){

    res.status(500).json(err);
  }
});

No trecho de código acima, antes de registrar ele procura para ver se este usuário existe, caso o resultado seja "null" ele criara um novo usuário.

Como requisito para terminar o projeto também é necessário que quando houver uma requisição do tipo GET para a mesma rota ela devolva um array de objetos com o nome de usuário e id dos usuários registrados,algo relativamente simples:

app.get('/api/users',async function(req,res){
  try{
    var users = [];
    users = await User.find();
    res.json(users);
  }catch(err){
    res.status(500).json(err);
  }

})

A resposta do tipo get deve ser assim:

Seguindo o desafio,devemos fazer com que a API possa salvar exercícios desde que ceda uma id(através da URL) de usuário,uma descrição e uma duração, caso uma data não seja cedida,devemos pegar a data atual.

app.post('/api/users/:_id/exercises', async function(req,res){
  const id = req.params._id;
  const data = req.body;

  let date;
  if(data.date == null || data.date == ''){
    date = new Date();
  }else{
    date = data.date;
  }

  try{
    const newexer = new exercise({
      duser: id,
      description:data.description,
      duration: data.duration,
      date:date
    });
    await newexer.save();
    const user = await User.findById(id).exec();

    res.json({
      username:  user.username,
      _id: user._id,
      description:newexer.description,
      duration:newexer.duration,
      date: new Date(newexer.date).toDateString()

    });
  }catch(err){
    res.status(500).json(err);

  }
});

Note que usaremos o campo "duser" para guardar o id do usuário. A rota de GET seguirá uma linha parecida com a anterior:

app.get('/api/users/:_id/exercises', async function(req,res){
  const id = req.params._id;
  try{
    const exers = await exercise.find({duser: id});
    res.json(exers);
 }catch(err){
    res.status(500).json(err);

  }
})

A rota agora construiremos a rota de logs, onde reside maior parte do desafio:
Quando solicitado à rota deve-ser devolver o objeto do usuário com o campo "count" que recebe o valor do número de exercicios cadastrados para o usuário, além do array dos exercicios, além da possibilidade de podermos filtrar por faixa de tempo, para isso usaremos o Postman.

Vendo a parte tracejada em vermelho,temos um exemplo de solicitação GET onde a Query esta na URL, no caso após "?" temos as condicionais que devem ser atendidas na consulta, para isso devemos criar um objeto que receba os parametros from,to e Limit usando o método "req.query", assim:

app.get('/api/users/:_id/logs',async function(req,res){
  const id = req.params._id;
  const { from, to, limit } = req.query;
  let dateObj = {}
  if (from) {
    dateObj["$gte"] = new Date(from)
  }
  if (to){
    dateObj["$lte"] = new Date(to)
  }
  let filter = {
    duser: id
  }
  if(from || to){
    filter.date = dateObj;
  }

  try{
    const user = await User.findById(id).exec();
    const exers = await exercise.find(filter).limit(+limit ?? 500);
    const num = await exercise.find({ duser: id}).count().exec();
    let log = exers.map((e) => {
            return {
                'description': e.description,
                    'duration': e.duration,
                'date': new Date(e.date).toDateString()
        };
    });
    res.json({
      username: user.username,
      count : num,
      _id: user._id,
     log});
 }catch(err){
    res.status(500).json(err);

  }
})

A resposta deve ser assim:

Por fim, o código completo:

const express = require('express')
const app = express()
const cors = require('cors')
require('dotenv').config()
const mongoose = require('mongoose');
const bodyParser = require('body-parser');

app.use(bodyParser.urlencoded({ extended: true }))
app.use(bodyParser.json());

app.use(cors())
app.use(express.static('public'))
app.get('/', (req, res) => {
  res.sendFile(__dirname + '/views/index.html')
});

const mySecret = process.env['MONGO_URI']

main().catch(err => console.log(err));

async function main() {
  await mongoose.connect(mySecret);
}
//-----------
const userSchema = mongoose.Schema({
  username: String,
  _id: String
});
const exerciseSchema = mongoose.Schema({
  duser: String,
  description:{
    type: String,
    required: true
  },
  duration:{
      type: Number,
      required: true
  },
  date: Date
});

var User = mongoose.model('user',userSchema);
var exercise = mongoose.model('exercise',exerciseSchema);
//------------
app.post('/api/users',async function(req,res){
  const user = req.body.username;
  try{
    const username = await User.findOne({username: user});
    if(username == null){
      let newId = new mongoose.mongo.ObjectId();
      const newUser = new User({username: req.body.username, _id: newId});
      await newUser.save();
      res.json({'username':newUser.username,'_id': newUser._id});
    }else{
      res.json({'username':username.username,'_id': username._id});
    }

  }catch(err){

    res.status(500).json(err);
  }
});
//--------------------
app.get('/api/users',async function(req,res){
  try{
    var users = [];
    users = await User.find();
    res.json(users);
  }catch(err){
    res.status(500).json(err);
  }

})

app.post('/api/users/:_id/exercises', async function(req,res){
  const id = req.params._id;
  const data = req.body;

  let date;
  if(data.date == null || data.date == ''){
    date = new Date();
  }else{
    date = data.date;
  }

  try{
    const newexer = new exercise({
      duser: id,
      description:data.description,
      duration: data.duration,
      date:date
    });
    await newexer.save();
    const user = await User.findById(id).exec();


    res.json({
      username:  user.username,
      _id: user._id,
      description:newexer.description,
      duration:newexer.duration,
      date: new Date(newexer.date).toDateString()

    });
  }catch(err){
    res.status(500).json(err);

  }
});

app.get('/api/users/:_id/exercises', async function(req,res){
  const id = req.params._id;
  try{
    const exers = await exercise.find({duser: id});
    res.json(exers);
 }catch(err){
    res.status(500).json(err);

  }
})

app.get('/api/users/:_id/logs',async function(req,res){
  const id = req.params._id;
  const { from, to, limit } = req.query;
  let dateObj = {}
  if (from) {
    dateObj["$gte"] = new Date(from)
  }
  if (to){
    dateObj["$lte"] = new Date(to)
  }
  let filter = {
    duser: id
  }
  if(from || to){
    filter.date = dateObj;
  }

  try{
    const user = await User.findById(id).exec();
    const exers = await exercise.find(filter).limit(+limit ?? 500);
    const num = await exercise.find({ duser: id}).count().exec();
    let log = exers.map((e) => {
            return {
                'description': e.
description
,
              'duration': e.duration,
                'date': new Date(e.date).toDateString()
        };
    });
    res.json({
      username: user.username,
      count : num,
      _id: user._id,
     log});
 }catch(err){
    res.status(500).json(err);

  }
})

const listener = app.listen(process.env.PORT || 3000, () => {
  console.log('Your app is listening on port ' + listener.address().port)
})

link do projeto no replit: https://replit.com/@AdrielH024/boilerplate-project-exercisetracker?v=1

link do projeto no github:
https://github.com/AdrielH024/free-Code-Camp-ExerciseTracker