Seguidores

sexta-feira, 28 de fevereiro de 2025

A Vida é Feita de Escolhas: Como o MCDM e a IA Podem Nos Ajudar a Decidir Melhor

INTRODUÇÃO

Contexto

Home Office de qualquer especialidade, que tenha interesse na utilização da IA para fazer escolhas e solucionar problemas.

Objetivo 

O objetivo deste post é enfatizar que o MCDM (Multiple Criteria Decision-Making) nos dá estrutura, a IA nos dá velocidade, e juntos eles transformam decisões em algo mais racional e menos estressante.

A Vida é Feita de Escolhas

"A vida é feita de escolhas" e "quem tem muitas opções sofre com a dúvida". 



Esses dois ditados populares resumem bem o que muitos de nós sentimos todos os dias. 

Seja decidir entre uma viagem para a praia ou a montanha, escolher um novo celular ou até mesmo algo simples como o jantar de hoje, estamos constantemente diante de escolhas. 

E, confesso, eu costumava fazer isso de forma impulsiva, guiado mais pela emoção do que pela razão.

 Acho que não estou sozinho nisso – a maioria das pessoas que conheço também decide assim, quase no piloto automático.

Mas hoje descobri algo que mudou minha perspectiva: existe um campo chamado MCDM (Multiple Criteria Decision-Making), ou "Tomada de Decisão com Múltiplos Critérios", que oferece ferramentas incríveis para estruturar nossas escolhas. 

E o mais surpreendente! Não é apenas um método, mas vários! 

Descobri enquanto testava meu primeiro Agente de IA, pedindo uma escolha com MCDM.

Veja os testes anteriores desse Agente no Post Navegando pelas Alucinações da IA: Uma Lição Sobre a Importância da Clareza Humana.

Testei com alguns Chatbots de IA do mercado, para comparar, esperando que o resultado fosse o mesmo.

No entanto, os resultados foram diferentes, para minha surpresa. Depois de perguntar a uma IA, entendi a razão: pedi apenas que usassem MCDM, logo, cada um escolheu um método. 

Eu, que achava que só existia uma forma de decidir racionalmente, fiquei impressionado com tantas opções – e, ironicamente, um pouco perdido com tanta dúvida. 

Por isso, neste post, quero compartilhar o que aprendi, ajudar você a entender esses métodos e mostrar como podemos usar a inteligência artificial (IA) junto com o MCDM para tomar decisões mais rápidas, inteligentes e com menos sofrimento.

Escolhas Impulsivas: Um Hábito Comum

Por muito tempo, eu tomava decisões sem pensar muito. 

Escolhia pelo "feeling", pelo que parecia mais emocionante ou confortável no momento. 

Às vezes dava certo, mas outras vezes… bem, nem tanto. 

Conversando com amigos e familiares, percebi que isso é comum: a gente decide com o coração e deixa a cabeça em segundo plano. 

O problema é que, quando as opções aumentam ou os critérios ficam conflitantes (tipo custo versus diversão), a dúvida vira um peso. 

Quem nunca ficou horas debatendo entre duas opções sem chegar a lugar nenhum?


A Descoberta do MCDM: Um Mundo de Métodos

Tudo mudou quando comecei a explorar o MCDM. 

Eu pensava que existia apenas uma forma "certa" de decidir racionalmente, mas descobri um universo de métodos! 

Cada um tem sua lógica e pode ser usado dependendo do tipo de escolha que enfrentamos. 

Aqui vão alguns que me chamaram a atenção:

  • AHP (Analytic Hierarchy Process): Organiza critérios em uma hierarquia e usa comparações par-a-par para definir prioridades. Perfeito para decisões complexas, como escolher um destino de viagem com base em diversão, custo e segurança.
  • TOPSIS: Ranqueia opções pela proximidade de um "ideal perfeito" e distância de um "pior cenário". É como encontrar o equilíbrio entre o sonho e o pesadelo!
  • WSM (Weighted Sum Model): Simples e direto – dá notas, aplica pesos e soma tudo. Ideal para escolhas rápidas.
  • ELECTRE: Elimina opções mais fracas e foca nas que "superam" as outras. Bom para quando os critérios não se compensam facilmente.
  • PROMETHEE: Cria rankings baseados em preferências, com uma abordagem mais visual e flexível.

Fiquei tão empolgado com tantas possibilidades que, por um momento, a dúvida voltou: qual método usar? 

Mas aí percebi que o importante é entender como eles funcionam e aplicá-los com ajuda da tecnologia – mais especificamente, da IA.


IA + MCDM: Uma Dupla Poderosa

Com toda a evolução tecnológica que vemos hoje – IA, automação, big data – as escolhas não vão desaparecer. 

Pelo contrário, elas vão ficar mais frequentes e complexas. 

Imagine ter que decidir entre 10 modelos de carro elétrico, cada um com dezenas de especificações!

Sozinho, eu me perderia, mas com a IA e o MCDM, posso delegar os cálculos pesados e focar no que importa.

Por exemplo, pedi a uma IA (no caso, o Grok, da xAI) para me explicar o AHP e o TOPSIS. 

Em minutos, ela fez os cálculos para escolher entre praia e montanha, levando em conta critérios como diversão e custo. 

O resultado? Praia venceu, com base nos pesos que definimos. Isso me economizou horas de dúvida e me deu confiança na escolha.


Por Que Isso Importa?

A vida é feita de escolhas, sim, mas não precisamos sofrer com elas. 

O MCDM nos dá estrutura, a IA nos dá velocidade, e juntos eles transformam decisões em algo mais racional e menos estressante. 

Não importa se a tecnologia evolui ou se o mundo fica mais complicado – sempre teremos que decidir.

 Então, por que não fazer isso da melhor forma possível?

Quero aprender mais sobre esses métodos e usá-los no dia a dia, seja para escolhas pessoais ou até profissionais. 

E quero que você venha comigo nessa jornada! 

Abaixo, deixei alguns links para explorar cada método. 

Vamos usar a razão, a tecnologia e um toque de emoção para decidir melhor?

Referências para Aprofundar

Considerações Finais

Espero que esse post tenha te inspirado a olhar para suas escolhas de um jeito novo. 

Eu, pelo menos, estou animado para testar mais o MCDM com a IA – quem sabe minha próxima decisão não vira outro post? 

Deixe seu comentário com uma escolha que você está enfrentando, e vamos pensar juntos como resolvê-la!


quarta-feira, 26 de fevereiro de 2025

Navegando pelas Alucinações da IA: Uma Lição Sobre a Importância da Clareza Humana

INTRODUÇÃO

Contexto

Home Office de qualquer especialidade, que tenha interesse em utilizar o MASP (Método de Análise e Solução de Problemas) junto com IA (Inteligência Artificial), para solução de problemas.

Objetivo

O objetivo deste post é reforçar a importância da clareza humana nas interações com Chatbots de IA.

Descrição de um desafio

A inteligência artificial (IA) tem o potencial de revolucionar a forma como resolvemos problemas e tomamos decisões. 

No entanto, como qualquer ferramenta poderosa, seu uso exige cuidado e atenção. 



Recentemente, tive uma experiência reveladora ao criar um Agente de IA para aplicar o Método de Análise e Solução de Problemas (MASP) em uma startup.

A Criação do Agente de IA e o Desafio da Escolha de Férias usando MCDM

Utilizando uma plataforma sem código, configurei um Agente de IA especializado no MASP, focando nas quatro primeiras etapas: Identificação do Problema, Observação, Análise e Plano de Ação. 

O objetivo era que o Agente, após receber as informações das etapas anteriores, elaborasse um Plano de Ação eficaz.

Para testar o Agente, utilizei um problema comum em muitas famílias: a escolha do destino das férias, entre praia e montanha. 

Munido das técnicas Diagrama de Ishikawa e 5 Porquês, a partir das perguntas abertas sugeridas por essa técnicas, formulei 30 perguntas e respostas específicas e as submeti ao Agente.

Saiba mais a respeito dos testes desse Agente no Post A Vida é Feita de Escolhas: Como o MCDM e a IA Podem Nos Ajudar a Decidir Melhor.

Surpresa e Reflexão: Quem Alucinou?

Para minha surpresa, o Plano de Ação gerado pelo Agente propunha melhorias na infraestrutura da cidade litorânea, ao invés de apresentar soluções para a escolha do destino das férias. 

Minha reação inicial foi atribuir o resultado a uma alucinação da IA. 

No entanto, após analisar cuidadosamente as perguntas e respostas que eu mesmo havia elaborado, percebi que a falha não era do Agente, mas sim minha.

O Plano de Ação do Agente estava, na verdade, coerente com as informações que eu havia fornecido. 

O problema não estava na IA, mas sim na minha comunicação. 

Eu havia especificado causas para o problema que, na verdade, eram critérios de escolha.

A Lição Aprendida: A Responsabilidade é Humana

Essa experiência me ensinou que a responsabilidade por "alucinações" da IA nem sempre é exclusiva da máquina. 

É fundamental analisar cuidadosamente a entrada de dados, seja na forma de comandos ou perguntas.

Antes de submeter as informações ao Agente, aprendi a importância de revisar:

  1. A integridade da informação: verificar se as causas especificadas são completas, precisas e válidas.
  2. A conexão direta: garantir que as causas estejam diretamente relacionadas ao problema identificado.

Uma revisão rigorosa e atenta pode evitar resultados inválidos e garantir que a IA seja utilizada de forma eficaz.

Conclusão: Alavancando o Mundo com a IA e o MASP

A frase de Arquimedes, "Dê-me um ponto de apoio e uma alavanca que moverei o mundo", nos convida a refletir sobre o potencial da IA como alavanca e do MASP como ponto de apoio para a resolução de problemas.

A sabedoria de Einstein, que enfatiza a importância de formular a pergunta certa antes de buscar a solução, nos lembra que o sucesso da IA depende da nossa capacidade de fornecer informações claras e precisas.

Ao investirmos tempo e esforço na elaboração de perguntas relevantes e na revisão cuidadosa das informações, podemos evitar "alucinações" e garantir que a IA seja uma ferramenta poderosa para a resolução de problemas e tomada de decisões.

Que essa experiência sirva de aprendizado para todos que buscam utilizar a IA de forma eficaz e responsável!

Outro Post sobre Alucinações da IA: Chega de Alucinações! Domine a IA com Prompts Estruturados em FSM

Saiba mais sobre o MASP: MASP (Método de Análise e Solução de Problemas)


sexta-feira, 21 de fevereiro de 2025

Seu sofrimento nas escolhas pode ser aliviado com assistente de IA

INTRODUÇÃO


Contexto

Home Office de qualquer especialidade, que tenha interesse em fazer Prompts de IA estruturados conforme o MCDM (Multiple Criteria Decision Make), a fim de facilitar escolhas quando houver vários critérios conflitantes.

Objetivo

O objetivo deste post é fornecer um modelo de Prompt de IA baseado no MCDM.

O problema: indecisão, ansiedade e medo de fazer a escolha errada

"A vida é feita de escolhas", já diz o ditado popular. 

Mas, quem nunca se viu paralisado diante de tantas opções, sentindo-se angustiado e indeciso? 

A "paralisia da escolha" é um problema comum, especialmente em tempos de abundância de informações e possibilidades. 

Mas, e se existisse uma maneira de aprender a escolher sem sofrer, com a ajuda da inteligência artificial?

Tomar decisões faz parte da nossa rotina, desde as mais simples até as mais complexas. 

Escolher o que comer no almoço, qual roupa vestir, qual carreira seguir ou qual casa comprar são apenas alguns exemplos. 

No entanto, o excesso de opções pode levar à indecisão, à ansiedade e ao medo de fazer a escolha errada.

A solução: assistentes de IA para a tomada de decisões

A inteligência artificial (IA) pode ser uma aliada poderosa na hora de tomar decisões mais assertivas e sem tanto sofrimento. 

Com a ajuda de assistentes de IA, é possível analisar dados, identificar padrões e avaliar diferentes cenários, fornecendo informações relevantes para que você possa escolher o melhor caminho.

Visão Geral

Como funciona?

Os assistentes de IA utilizam métodos de tomada de decisão multicritério (MCDM), que consistem em:

  1. Definir o problema: Identificar qual é a decisão que precisa ser tomada, quais são as alternativas disponíveis e quais são os critérios importantes para a escolha.
  2. Avaliar as alternativas: Analisar cada alternativa em relação aos critérios definidos, atribuindo valores ou notas para cada um deles.
  3. Comparar os critérios: Avaliar a importância relativa de cada critério, ou seja, qual deles é mais relevante para a decisão final.
  4. Analisar os resultados: O assistente de IA combina as informações das etapas anteriores e apresenta um ranking das alternativas, indicando qual delas é a mais adequada de acordo com os seus critérios e preferências.

Exemplo prático

Imagine que você está em dúvida entre viajar para a praia ou para a montanha nas suas próximas férias. Você pode usar um assistente de IA para te ajudar a decidir.

Objetivo

Escolher uma das alternativas abaixo, utilizando MCDM (Multiple Criteria Decision Make), informando o resultado numérico de cada opção, explicando como foi feita a transformação de texto para número, como chegou ao resultado e fornecendo informações adicionais úteis.

Questionário com 2 alternativas e 3 critérios

  • Alternativa 1: Viajar para a praia
  • Alternativa 2: Viajar para a montanha
  • Critério 1: Custo
  • Critério 2: Diversão
  • Critério 3: Paz

Avaliação

  • Nome da Avaliação: Excelente, Ótimo, Bom, Ruim, Péssimo
  • Avaliação do critério 1 na alternativa 1: Bom
  • Avaliação do critério 2 na alternativa 1: Excelente
  • Avaliação do critério 3 na alternativa 1: Péssimo
  • Avaliação do critério 1 na alternativa 2: Ótimo
  • Avaliação do critério 2 na alternativa 2: Bom
  • Avaliação do critério 3 na alternativa 2: Excelente

Importância Relativa

  • Nome do Importância Relativa: Extremamente menos importante, Muito menos importante, Igualmente importantes, Muito mais importante, Extremamente mais importante
  • Importância do critério 1 (Custo) vs. critério 2 (Diversão): Igualmente importantes
  • Importância do critério 1 (Custo) vs. critério 3 (Paz): Extremamente menos importante
  • Importância do critério 2 (Diversão) vs. critério 3 (Paz): Muito mais importante

Com base nessas informações, o assistente de IA irá gerar um resultado numérico para cada alternativa, levando em consideração suas avaliações e a importância relativa de cada critério. O resultado final te ajudará a tomar a decisão mais adequada para você.

Benefícios de usar assistentes de IA

  • Racionalidade: A IA ajuda a tomar decisões mais racionais, baseadas em dados e análises, e não apenas em emoções ou intuições.
  • Eficiência: A IA agiliza o processo de tomada de decisão, permitindo que você avalie diversas alternativas de forma rápida e precisa.
  • Redução do estresse: A IA diminui a ansiedade e o medo de errar, pois oferece informações claras e relevantes para a escolha.
  • Aprendizado: Ao utilizar assistentes de IA, você aprende a identificar seus critérios e preferências, tornando-se um tomador de decisões mais consciente e confiante.

CONCLUSÃO

A inteligência artificial está cada vez mais presente em nosso dia a dia, facilitando diversas tarefas e nos ajudando a tomar decisões mais assertivas. 

Se você sofre com a "paralisia da escolha", experimente utilizar um assistente de IA e descubra como a tecnologia pode te ajudar a escolher sem sofrer.

Utilize o Modelo de Prompt de IA para Tomada de Decisão Mukticritério (MCDM), que segue abaixo.

Prompt de IA para Tomada de Decisão Multicritério (MCDM)

OBJETIVO

Escolher uma das alternativas abaixo, utilizando MCDM (Multiple Criteria Decision Make), informando o resultado numérico de cada opção, explicando como foi feita a transformação de texto para número, como chegou ao resultado e fornecendo informações adicionais úteis.

QUESTIONÁRIO COM [Número de Alternativas] ALTERNATIVAS E [Número de Critérios] CRITÉRIOS

  • Alternativa 1: [Escrever o nome da alternativa 1]
  • Alternativa 2: [Escrever o nome da alternativa 2]
  • ... (Repetir para cada alternativa)
  • Critério 1: [Escrever o nome do critério 1]
  • Critério 2: [Escrever o nome do critério 2]
  • ... (Repetir para cada critério)

AVALIAÇÃO

  • Nome da Avaliação: Excelente, Ótimo, Bom, Ruim, Péssimo (Você pode adicionar outras opções de avaliação, se necessário)
  • Avaliação do critério 1 na alternativa 1: [Nome da avaliação do critério]
  • Avaliação do critério 2 na alternativa 1: [Nome da avaliação do critério]
  • ... (Repetir para cada critério em cada alternativa)

GRAU DE IMPORTÂNCIA

  • Nome do Grau de Importância: Extremamente menos importante, Muito menos importante, Igualmente importantes, Muito mais importante, Extremamente mais importante (Você pode adicionar outras opções de grau de importância, se necessário)
  • Grau de importância do critério 1 vs. critério 2: [Nome do Grau de Importância]
  • Grau de importância do critério 1 vs. critério 3: [Nome do Grau de Importância]
  • ... (Repetir para todas as combinações de critérios)

Observações

  • Substitua os espaços entre colchetes ([...]) pelas informações específicas do seu problema de decisão.
  • Você pode adicionar ou remover alternativas e critérios, ajustando o número na seção "QUESTIONÁRIO".
  • As opções de avaliação e grau de importância podem ser adaptadas de acordo com a sua necessidade.
  • Ao fornecer o prompt para a IA, seja o mais claro e detalhado possível para obter os melhores resultados.

Com este modelo de prompt, você pode facilmente adaptá-lo para diferentes cenários de tomada de decisão, simplesmente alterando as informações específicas do problema. Isso permite que você utilize a IA como uma ferramenta poderosa para tomar decisões mais informadas e eficientes.

Outros modelos de Prompt:

Prompt estruturado em GPS: Melhore as entregas nos seus processos pessoais usando GPS e IA: Guia Completo

Prompt estruturado em FSM: Chega de Alucinações! Domine a IA com Prompts Estruturados em FSM

Prompt estruturado em MASP: Estudo de Caso 1-3: Como fazer sem saber, experimentando GPS, IA e MASP - Exemplo de Prompt usando MASP

















quinta-feira, 20 de fevereiro de 2025

Chega de Alucinações! Domine a IA com Prompts Estruturados em FSM

 INTRODUÇÃO: Desmistificando a IA e a "Alucinação"

Contexto

Home Office especializado em TI, especificamente na área de programação, que tenha interesse em escrever Prompts estruturados em FSM (Finite State Machine), para geração automática de código.

Objetivo

Reforçar a importância da comunicação clara com a IA, para se obter ganhos de produtividade e qualidade na codificação de programas e evitar "alucinações".

Especificações e Alucinações

Com a utilização cada vez mais abrangente da IA, é comum ouvirmos pessoas de diferentes ambientes de trabalho citando casos de frustrações com as “alucinações” da IA.



Um programador frustrado com a "alucinação" da IA.


Por outro lado, é comum ouvirmos, também, pessoas razoavelmente experientes na utilização da IA, explicarem que a IA não “alucina”, apenas responde a prompts mal formulados.

Como programador de computador, mesmo com o pouco tempo de experiência na utilização da IA, posso afirmar que, todas as vezes que houve frustração nas minhas expectativas para geração automática de código, foi por falta de integridade das especificações que eu enviei no prompt.

Quando digo falta de integridade das especificações, significa que a informação estava “incompleta”, ou “imprecisa”, ou “inválida”.

No contexto da programação de computador, a chave para uma comunicação eficaz com a IA é apresentar os prompts como FSM (Finite State Machine).

Um diagrama de fluxo representando um prompt FSM.



Visão Geral: Entendendo o Poder da FSM

FSM é um modelo computacional que representa um sistema com um número finito de estados e transições entre eles. 

Perfeito para descrever o fluxo de um programa! 

Com prompts estruturados em FSM, você define:

  • Estados: As diferentes situações em que o programa pode estar.
  • Eventos: Os acontecimentos que causam a mudança de estado.
  • Ações: As respostas do programa a cada evento.
  • Transições: As regras que determinam a passagem de um estado para outro.

Exemplo 1: Um Robô que Serve Café

Imagine um robô que prepara café.



Podemos definir os seguintes estados:

  • Parado: Robô ocioso.
  • Preparando: Robô moendo café, esquentando água e preparando a bebida.
  • Servindo: Robô entregando o café.
  • Finalizado: Café pronto e robô pronto para a próxima tarefa.

Os eventos podem ser:

  • Botão pressionado: Cliente pede café.
  • Café pronto: Preparo finalizado.
  • Entrega concluída: Cliente pegou o café.

As ações seriam:

  • Moer café: Iniciar o processo de moagem.
  • Esquentar água: Ligar o aquecedor.
  • Preparar café: Combinar os ingredientes.
  • Servir café: Levar o café ao cliente.

Com um prompt FSM, você diria à IA:

  • Estado: Parado
  • Evento: Botão pressionado
  • Ação: Moer café, Esquentar água, Preparar café
  • Próximo estado: Preparando

  • Estado: Preparando
  • Evento: Café pronto
  • Ação: Servir café
  • Próximo estado: Servindo

  • Estado: Servindo
  • Evento: Entrega concluída
  • Ação: Nenhuma
  • Próximo estado: Finalizado

Modelo de Prompt Genérico

  • Estado: <nome do estado>
  • Evento: <nome do evento>
  • Ação: <lista de ações>
  • Próximo estado: <nome do próximo estado>

Diga Adeus às Alucinações!

Com prompts FSM, você terá:

  • Especificações claras e completas: Sem margem para interpretações erradas.
  • Código previsível e confiável: Resultados consistentes com suas intenções.
  • Controle total sobre a IA: Você define o comportamento do programa.
  • Comece a usar FSM hoje mesmo e eleve sua programação a um novo nível!

Modelo de Prompt FSM: A Receita para o Sucesso

Formato do Prompt:

  • Estado: Descrição da situação do programa.
  • Evento: Acontecimento que causa a mudança de estado.
  • Ação: Resposta do programa ao evento (geração de código, chamada de função, etc.).
  • Próximo Estado: Para onde o programa vai após a ação.

Dicas para Criar Prompts FSM:

  • Seja Específico: Quanto mais detalhes, melhor.
  • Use Linguagem Clara: Evite ambiguidades.
  • Divida em Estados: Quebre o problema em partes menores.
  • Pense nas Transições: Garanta que todos os caminhos estejam cobertos.
  • Teste e Refine: Ajuste o prompt até obter o resultado desejado.

A seguir, será apresentado o Exemplo 2, detalhado para:

  • Criar um exemplo prático de um programa simples (ex: login em um aplicativo).
  • Mostrar como modelar o comportamento desse programa usando uma FSM.
  • Converter a FSM em um prompt seguindo o formato proposto.
  • Mostrar como a IA gera o código correspondente, passo a passo.

Exemplo 2: FSM para Login de Usuário com Opção "Esqueci Minha Senha"

Para ilustrar o uso de FSM em um cenário de login com a opção "Esqueci minha senha", vamos criar um exemplo detalhado e didático.

Estados

  • Tela de Login: O usuário está na tela inicial de login.
  • Credenciais Inválidas: O usuário errou o login e está na tela de erro.
  • Esqueci Minha Senha: O usuário solicitou a recuperação da senha.
  • Enviando Email: O sistema está enviando o email de recuperação.
  • Email Enviado: Email de recuperação enviado com sucesso.
  • Redefinir Senha: O usuário está na tela de redefinição de senha.
  • Senha Redefinida: Senha alterada com sucesso.

Eventos

  • Login: Usuário tenta fazer login.
  • Credenciais Erradas: Login falhou.
  • Esqueci Senha: Usuário clica em "Esqueci minha senha".
  • Email enviado: Email de recuperação enviado.
  • Falha no Envio: Falha ao enviar o email de recuperação.
  • Redefinir Senha: Usuário redefine a senha.
  • Sucesso na Redefinição: Senha alterada com sucesso.
  • Erro na Redefinição: Falha ao redefinir a senha.

Ações

  • Validar Credenciais: Verificar se o login está correto.
  • Exibir Mensagem de Erro: Mostrar mensagem de login inválido.
  • Enviar Email de Recuperação: Enviar email com link para redefinição.
  • Exibir Mensagem de Sucesso: Mostrar mensagem de email enviado.
  • Exibir Mensagem de Falha: Mostrar mensagem de falha no envio.
  • Redirecionar para Redefinição: Levar o usuário para a tela de redefinição.
  • Atualizar Senha: Alterar a senha no banco de dados.
  • Exibir Mensagem de Sucesso na Redefinição: Mostrar mensagem de senha alterada.
  • Exibir Mensagem de Erro na Redefinição: Mostrar mensagem de falha na redefinição.

Transições

Tela de Login

  • Login -> Validar Credenciais 
    • Credenciais Erradas -> Credenciais Inválidas
    • Esqueci Senha -> Esqueci Minha Senha

Credenciais Inválidas

  • Login -> Validar Credenciais 
    • Esqueci Senha -> Esqueci Minha Senha

Esqueci Minha Senha

  • Email enviado -> Enviando Email 
    • Falha no Envio -> Exibir Mensagem de Falha

Enviando Email

  • Email Enviado -> Email Enviado 
    • Falha no Envio -> Exibir Mensagem de Falha

Email Enviado

  • Redefinir Senha -> Redefinir Senha

Redefinir Senha

  • Sucesso na Redefinição -> Senha Redefinida 
    • Erro na Redefinição -> Exibir Mensagem de Erro na Redefinição

Senha Redefinida

  • Login -> Validar Credenciais


Formato do Prompt para IA

Estado: <nome do estado>

Evento: <nome do evento>

Ação: <lista de ações>

Próximo estado: <nome do próximo estado>


Exemplo de Prompt para IA

Estado: Tela de Login
Evento: Login
Ação: Validar Credenciais
Próximo estado: Credenciais Inválidas

Estado: Tela de Login
Evento: Esqueci Senha
Ação: Redirecionar para Esqueci Minha Senha
Próximo estado: Esqueci Minha Senha

Estado: Credenciais Inválidas
Evento: Login
Ação: Validar Credenciais
Próximo estado: Credenciais Inválidas

Estado: Credenciais Inválidas
Evento: Esqueci Senha
Ação: Redirecionar para Esqueci Minha Senha
Próximo estado: Esqueci Minha Senha

Estado: Esqueci Minha Senha
Evento: Email enviado
Ação: Enviar Email de Recuperação
Próximo estado: Enviando Email

Estado: Esqueci Minha Senha
Evento: Falha no Envio
Ação: Exibir Mensagem de Falha
Próximo estado: Esqueci Minha Senha

Estado: Enviando Email
Evento: Email Enviado
Ação: Exibir Mensagem de Sucesso
Próximo estado: Email Enviado

Estado: Enviando Email
Evento: Falha no Envio
Ação: Exibir Mensagem de Falha
Próximo estado: Esqueci Minha Senha

Estado: Email Enviado
Evento: Redefinir Senha
Ação: Redirecionar para Redefinir Senha
Próximo estado: Redefinir Senha

Estado: Redefinir Senha
Evento: Sucesso na Redefinição
Ação: Atualizar Senha, Exibir Mensagem de Sucesso na Redefinição
Próximo estado: Senha Redefinida

Estado: Redefinir Senha
Evento: Erro na Redefinição
Ação: Exibir Mensagem de Erro na Redefinição
Próximo estado: Redefinir Senha

Estado: Senha Redefinida
Evento: Login
Ação: Validar Credenciais
Próximo estado: Tela de Login

Observações

  • Este é um exemplo simplificado, e pode ser adaptado para incluir mais detalhes e funcionalidades.
  • A ordem dos eventos e ações pode variar dependendo da implementação do aplicativo.
  • É importante testar o prompt com a IA para garantir que o código gerado funcione corretamente.

Com este exemplo, você pode criar um prompt FSM completo e detalhado para sua IA, garantindo que o código gerado corresponda ao comportamento desejado para o fluxo de login do seu aplicativo.

Exemplo 2: Geração de Código Javascript para Exemplo de FSM de Login com "Esqueci Minha Senha"

Resposta do Chatbot de IA: Com base no exemplo de FSM para login de usuário com a opção "Esqueci minha senha" que você forneceu, posso gerar um código Javascript que simula o fluxo de estados e eventos. 
Um exemplo de código de um prompt FSM.



No entanto, é importante lembrar que este código é uma simplificação e não inclui funcionalidades como validação de dados, comunicação com servidor ou interface gráfica.

JavaScript
// Definição dos estados
const estados = {
  TELA_DE_LOGIN: "tela_de_login",
  CREDENCIAIS_INVALIDAS: "credenciais_invalidas",
  ESQUECI_MINHA_SENHA: "esqueci_minha_senha",
  ENVIANDO_EMAIL: "enviando_email",
  EMAIL_ENVIADO: "email_enviado",
  REDEFINIR_SENHA: "redefinir_senha",
  SENHA_REDEFINIDA: "senha_redefinida",
};

// Definição dos eventos
const eventos = {
  LOGIN: "login",
  CREDENCIAIS_ERRADAS: "credenciais_erradas",
  ESQUECI_SENHA: "esqueci_senha",
  EMAIL_ENVIADO: "email_enviado",
  FALHA_NO_ENVIO: "falha_no_envio",
  REDEFINIR_SENHA: "redefinir_senha",
  SUCESSO_NA_REDEFINICAO: "sucesso_na_redefinicao",
  ERRO_NA_REDEFINICAO: "erro_na_redefinicao",
};

// Estado inicial
let estadoAtual = estados.TELA_DE_LOGIN;

// Função para lidar com os eventos
function lidarComEvento(evento, dados) {
  console.log(`Estado atual: ${estadoAtual}, Evento: ${evento}`);

  switch (estadoAtual) {
    case estados.TELA_DE_LOGIN:
      if (evento === eventos.LOGIN) {
        // Simulação de validação de credenciais
        if (dados.usuario === "usuario" && dados.senha === "senha") {
          estadoAtual = estados.SENHA_REDEFINIDA;
        } else {
          estadoAtual = estados.CREDENCIAIS_INVALIDAS;
        }
      } else if (evento === eventos.ESQUECI_SENHA) {
        estadoAtual = estados.ESQUECI_MINHA_SENHA;
      }
      break;

    case estados.CREDENCIAIS_INVALIDAS:
      if (evento === eventos.LOGIN) {
        // Simulação de validação de credenciais
        if (dados.usuario === "usuario" && dados.senha === "senha") {
          estadoAtual = estados.SENHA_REDEFINIDA;
        } else {
          estadoAtual = estados.CREDENCIAIS_INVALIDAS;
        }
      } else if (evento === eventos.ESQUECI_SENHA) {
        estadoAtual = estados.ESQUECI_MINHA_SENHA;
      }
      break;

    case estados.ESQUECI_MINHA_SENHA:
      if (evento === eventos.EMAIL_ENVIADO) {
        estadoAtual = estados.ENVIANDO_EMAIL;
      } else if (evento === eventos.FALHA_NO_ENVIO) {
        console.log("Falha ao enviar email de recuperação.");
      }
      break;

    case estados.ENVIANDO_EMAIL:
      if (evento === eventos.EMAIL_ENVIADO) {
        estadoAtual = estados.EMAIL_ENVIADO;
      } else if (evento === eventos.FALHA_NO_ENVIO) {
        console.log("Falha ao enviar email de recuperação.");
      }
      break;

    case estados.EMAIL_ENVIADO:
      if (evento === eventos.REDEFINIR_SENHA) {
        estadoAtual = estados.REDEFINIR_SENHA;
      }
      break;

    case estados.REDEFINIR_SENHA:
      if (evento === eventos.SUCESSO_NA_REDEFINICAO) {
        estadoAtual = estados.SENHA_REDEFINIDA;
      } else if (evento === eventos.ERRO_NA_REDEFINICAO) {
        console.log("Erro ao redefinir senha.");
      }
      break;

    case estados.SENHA_REDEFINIDA:
      if (evento === eventos.LOGIN) {
        // Simulação de validação de credenciais
        if (dados.usuario === "usuario" && dados.senha === "senha") {
          console.log("Login realizado com sucesso!");
          estadoAtual = estados.TELA_DE_LOGIN;
        } else {
          estadoAtual = estados.CREDENCIAIS_INVALIDAS;
        }
      }
      break;
  }

  console.log(`Novo estado: ${estadoAtual}`);
}

// Exemplos de uso
lidarComEvento(eventos.LOGIN, { usuario: "usuario", senha: "senha" }); // Login
lidarComEvento(eventos.ESQUECI_SENHA); // Esqueci minha senha
lidarComEvento(eventos.EMAIL_ENVIADO); // Email enviado
lidarComEvento(eventos.REDEFINIR_SENHA); // Redefinir senha
lidarComEvento(eventos.SUCESSO_NA_REDEFINICAO); // Senha redefinida
lidarComEvento(eventos.LOGIN, { usuario: "usuario", senha: "senha" }); // Login com sucesso

Este código demonstra como os estados e eventos podem ser gerenciados em Javascript para simular o fluxo de um sistema de login com a opção "Esqueci minha senha". 

Você pode adaptá-lo e expandi-lo para incluir mais funcionalidades e integrá-lo a uma interface gráfica.

Lembre-se de que este código é apenas um exemplo e requer adaptações para um cenário real, como validação de dados, comunicação com um servidor para autenticação e persistência de dados.

Conclusão: Domine a IA e Crie Códigos Incríveis

Reforçamos a importância da comunicação clara com a IA, para se obter ganhos de produtividade e qualidade na codificação de programas.

Incentivamos os leitores a experimentar os prompts FSM em seus projetos.

Convidamos os leitores a compartilhar suas experiências e dúvidas nos comentários.

Ferramentas

Aqui estão algumas ferramentas que podem ajudar você a criar Diagramas FSM:

  • Visual Paradigm: Uma ferramenta online poderosa que permite criar diagramas de máquina de estado e outros diagramas UML de forma fácil e rápida. Possui funcionalidades como arrastar e soltar, integração com MS Office e exportação para vários formatos.
  • Chat Diagram: Um criador de diagramas de máquinas de estado gratuito com IA. Permite criar diagramas de fluxo impressionantes em minutos, transformando suas ideias em obras-primas visuais sem esforço.
  • Creately: Um software inovador que permite criar diagramas de estados de maneira simples e intuitiva. Possui uma biblioteca abrangente de diagramas e atalhos de diagramação, além de colaboração em tempo real.

Casos de Uso: Cenários Reais Onde Prompts FSM Brilham

Os prompts baseados em FSM (Finite State Machine) são incrivelmente vantajosos em uma variedade de cenários de programação, especialmente aqueles que envolvem lógica de fluxo complexa e interações dinâmicas. Aqui estão alguns exemplos reais onde eles podem fazer a diferença:

1. Automação de Tarefas

Robôs: Imagine um robô industrial que precisa executar uma sequência específica de passos para montar um produto. Um prompt FSM pode definir os estados (aguardando peça, posicionando braço, soldando, etc.) e os eventos (peça detectada, braço posicionado, solda concluída) que ditam as ações do robô.

Assistentes Virtuais: Um chatbot que guia o usuário por um processo de compra pode usar um prompt FSM para gerenciar os estados da conversa (saudação, escolha de produto, pagamento, confirmação) e as ações correspondentes a cada interação do usuário.

2. Desenvolvimento de Jogos

Inteligência Artificial (IA) de Inimigos: Um personagem inimigo em um jogo pode ter seu comportamento definido por um prompt FSM, com estados como "patrulhando", "atacando", "fugindo" e eventos como "jogador avistado", "vida baixa", "sem munição".

Controle de Personagens: As ações de um personagem do jogador podem ser mapeadas em um prompt FSM, com estados como "correndo", "pulando", "atacando" e eventos como "tecla de corrida pressionada", "barra de espaço pressionada", "botão do mouse clicado".

3. Sistemas Embarcados

Controladores Lógicos Programáveis (CLPs): Um CLP que controla uma linha de produção pode usar um prompt FSM para definir os estados da máquina (ligada, desligada, em operação, em falha) e os eventos (sensor ativado, botão de emergência pressionado, falha detectada) que determinam as ações do sistema.

Dispositivos IoT: Um dispositivo IoT que monitora a temperatura de um ambiente pode usar um prompt FSM para gerenciar os estados (temperatura normal, temperatura alta, temperatura baixa) e os eventos (leitura de sensor, limite excedido) que disparam alertas ou ações corretivas.

4. Aplicações Web e Mobile

Fluxos de Usuário: Um aplicativo de e-commerce pode usar um prompt FSM para definir os estados do usuário durante o processo de checkout (carrinho, endereço, pagamento, confirmação) e os eventos (próximo passo, voltar, cancelar) que guiam o usuário pela compra.

Um chatbot atendendo clientes em um site de e-commerce.


Gerenciamento de Sessões: Um aplicativo web pode usar um prompt FSM para controlar os estados de login do usuário (logado, deslogado, aguardando confirmação) e os eventos (login, logout, confirmação de email) que gerenciam o acesso ao sistema.

Limitações: Quando FSM Pode Não Ser a Melhor Opção

Embora os prompts FSM sejam poderosos, eles têm algumas limitações que devem ser consideradas:

1. Complexidade Excessiva

Muitos Estados e Transições: Se o sistema tiver um número muito grande de estados e transições, o prompt FSM pode se tornar complexo e difícil de manter. 

Um diagrama complexo com muitos estados e transições.


Nesses casos, outras abordagens como diagramas de estado ou linguagens de modelagem podem ser mais adequadas.

2. Sistemas Não Determinísticos

Eventos Imprevisíveis: Se o sistema lidar com eventos que não podem ser previstos ou controlados (como entradas de usuário aleatórias ou falhas de hardware), a FSM pode não ser a melhor maneira de modelar o comportamento.

3. Requisitos de Desempenho

Tempo Real: Em sistemas que exigem respostas rápidas a eventos, a FSM pode não ser a opção mais eficiente, pois a busca por estados e transições pode levar tempo.

4. Manutenção e Escalabilidade

Dificuldade de Modificação: Se o sistema precisar ser alterado ou expandido, o prompt FSM pode ser difícil de modificar, especialmente se houver muitas dependências entre estados e transições.

Alternativas

Quando a FSM não é a melhor opção, outras abordagens podem ser consideradas:

  • Diagramas de Estado: Úteis para visualizar sistemas complexos com muitos estados e transições.
  • Linguagens de Modelagem: Oferecem recursos mais avançados para modelar sistemas complexos e não determinísticos.
  • Programação Orientada a Eventos: Adequada para sistemas que lidam com eventos imprevisíveis.

Resumo

No contexto de uma Máquina de Estado Finito (FSM - Finite State Machine), os conceitos de Estado e Evento são definidos da seguinte forma:

  1. Estado:

    • Representa uma condição ou situação específica em que a máquina se encontra em um determinado momento.
    • Um estado armazena informações sobre o passado e reflete as mudanças desde o início do sistema até o momento atual.
    • Exemplo: Em um sistema de rádio, o estado pode ser "Reproduzindo CD" ou "Sintonizando Rádio".
  2. Evento:

    • É uma ocorrência ou entrada que pode causar uma transição de um estado para outro.
    • Um evento é o gatilho que ativa a mudança de estado, dependendo das condições definidas.
    • Exemplo: Pressionar o botão "Próximo" pode ser um evento que muda o estado de "Reproduzindo CD" para "Próxima Faixa".

Esses conceitos são fundamentais para modelar sistemas que dependem de condições e transições específicas. Você pode explorar mais sobre FSMs aqui

Exemplos de especificação de um Agente de IA usando FSM

O agente desse exemplo usa uma planilha Google com várias abas como fonte e destino dos dados e tem como objetivo assistir um profissional na gestão do seu processo pessoal.

As especificações estão detalhadas em vários posts, para facilitar o entendimento, compondo uma série com vários episódios.

A planilha Google pode ser baixada do Google Drive.

Seguem abaixo os links dos posts:
A proposta deste exemplo é submeter um documento para algumas plataformas de IA, para criar o agente, a fim de verificar se as especificações estão completas, precisas e válidas. 

Exemplos de código para implementação usando FSM

Nestes exemplos as especificações foram fornecidas ao Chatbot de IA por partes, sendo cada parte um evento.

Seguem abaixo os links dos posts, que contêm o código de implementação dos eventos:

Exemplos de código para manutenção e teste usando FSM

Nestes exemplos as especificações da manutenção foram fornecidas ao Chatbot de IA, com o objetivo de implementar a interface com o usuário, para cada evento.

Seguem abaixo os links dos posts, que contêm o código de menutenção dos eventos:

Conclusão

Os prompts FSM são uma ferramenta poderosa para criar código previsível e confiável, mas é importante conhecer suas limitações e considerar outras abordagens quando necessário. 

Ao escolher a técnica de modelagem certa para cada situação, você estará no caminho certo para criar sistemas eficientes e de fácil manutenção.

Outros modelos de Prompt:

Prompt estruturado em GPS: Melhore as entregas nos seus processos pessoais usando GPS e IA: Guia Completo

Prompt estruturado em MASP (Exemplo 1): Estudo de Caso T1E3: Como fazer sem saber, experimentando GPS, IA e MASP - Exemplo de Prompt usando MASP

Prompt estruturado em MCDM: Seu sofrimento nas escolhas pode ser aliviado com assistente de IA

Post sobre Alucinações da IA: Navegando pelas Alucinações da IA: Uma Lição Sobre a Importância da Clareza Humana

Prompt estruturado em MASP (Exemplo 2): Do Caos ao Prompt T1E1: Transformando Problemas Simples em Soluções Inteligentes com IA - Melhoria em App



terça-feira, 18 de fevereiro de 2025

Estudo de Caso T1E3: Como fazer sem saber, experimentando GPS, IA e MASP - Exemplo de Prompt usando MASP

INTRODUÇÃO



Se você preferir vídeo, em vez de texto, assista clicando aqui.

Contexto

Home Office de qualquer especialidade, que tenha interesse em aprender como usar o MASP (Método de Análise e Solução de Problemas) para coletar, analisar e registrar dados a respeito de um problema qualquer, e fornecer esses dados para um Prompt de um Chatbot de IA ajudar na solução.

Objetivo

O objetivo deste Post é mostrar um Prompt completo, elaborado com base no MASP, para pedir a um Chatbot de IA, um Plano de Ação para resolver um problema.


VISÃO GERAL

Se você preferir vídeo, em vez de texto, assista clicando aqui.

O Prompt contém estas etapas do MASP:
  • Identificação do Problema - utiliza a técnica 5W1H;
  • Observação - utiliza a técnica Diagrama de Ishikawa ou Causa e Efeito;
  • Análise - utiliza a técnica 5Why.
A resposta do Chatbot de IA contém estas etapas do MASP:
  • Plano de Ação - resposta completa do Chatbot de IA;
  • Ação - resposta que pode ser incompleta, já que nem todas as ações podem ser feitas por IA, pelo menos, por enquanto.

Prompt Completo

Este Prompt está completo, ou seja, tem todo o texto que foi encaminhado ao Chatbot de IA, incluindo fragmentos de código Java.

1 PERSONAGEM
1.1 Qual o papel do Chatbot? Profissional de TI especialista em programação na linguagem Java, implementando mudança num aplicativo, usando o IDE Eclipse.

2 IDENTIFICAÇÃO DO PROBLEMA: Definir claramente o problema.
2.1 [What?]  - O que aconteceu diferente esperado? A mensagem abaixo
Exception in thread "main" java.lang.ExceptionInInitializerError
at mobi.stos.caixadosaber.gui.SplashUI.initComponents(SplashUI.java:92)
at mobi.stos.caixadosaber.gui.SplashUI.<init>(SplashUI.java:23)
at Main.main(Main.java:20)
Caused by: java.lang.NullPointerException
at mobi.stos.caixadosaber.commons.OpenSansInterface.<clinit>(OpenSansInterface.java:17)
... 3 more
2.2 [Who?]   - Quem iniciou a execução? O próprio desenvolvedor
2.3 [When?]  - Evento que iniciou a execução? Dentro do Eclipse, clique no botão direito no nome do projeto / Run As / 1 Java Application
2.4 [Where?] - Onde a execução parou? Na classe SplashUI.java
2.5 [Why?]   - Por que a execução parou? java.lang.NullPointerException
2.6 [How?]   - Como é o procedimento, passo a passo, para reproduzir o erro? Dentro do Eclipse executar os passos abaixo:
2.6.1 Passo 1: Dentro do Eclipse, clicar com o botão direito no nome do arquivo;
2.6.2 Passo 2: No menu de contexto, clicar em Run As
2.6.3 Passo 3: No submenu de contexto, clicar em 1 Java Application

3 OBSERVAÇÃO: Investigar as características específicas do problema com uma visão ampla e sob vários pontos de vista.
3.1 [Mão de Obra?]
3.1.1 Conhecimento de Java? Falta de conhecimento adequado sobre Java, da pessoa que está fazendo a mudança.
3.1.2 Conhecimento do App? Falta de conhecimento adequado sobre o Aplicativo em manutenção, da pessoa que está fazendo a mudança.
3.2 [Máquina?]
3.2.1 Versão do Eclipse? 2024-09 (4.33.0)
3.2.2 Versão do JDK? jdk-8u441-windows-x64
3.3 [Método?]
3.3.1 Código da classe onde parou?
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package mobi.stos.caixadosaber.gui;

import mobi.stos.caixadosaber.commons.OpenSansInterface;
import mobi.stos.caixadosaber.task.InitTask;
import mobi.stos.caixadosaber.util.Icon;
import mobi.stos.caixadosaber.util.SQLite;

/**
 *
 * @author 
 */
public class SplashUI extends javax.swing.JFrame implements OpenSansInterface {

    /**
     * Creates new form SplashUI
     */
    public SplashUI() {
        initComponents();
        this.setIconImage(Icon.instance().image);
    }

    /**
     * This method is called from within the constructor to initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is always
     * regenerated by the Form Editor.
     */
    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
    private void initComponents() {
...
        jLabel2 = new javax.swing.JLabel();
...
        jLabel2.setFont(openSans);
...        
}
3.3.2 Código da linha SplashUI.java:92?
jLabel2.setFont(openSans);
3.3.3 Código da interface implementada na classe onde parou (SplashUI.java)?
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package mobi.stos.caixadosaber.commons;

import java.awt.Font;
import mobi.stos.caixadosaber.util.CustomFont;

/**
 *
 * @author 
 */
public interface OpenSansInterface {

    public final Font openSans_mini = CustomFont.openSans().deriveFont(12f);
    public final Font openSans = CustomFont.openSans().deriveFont(14f);
    public final Font openSans_large = CustomFont.openSans().deriveFont(20f);

}
3.4 [Material?]
3.4.1 Bibliotecas de Terceiros? Há bibliotecas externas com bugs ou incompatíveis? Não sei como verificar.
3.4.2 APIs Externas? Há APIs instáveis ou desatualizadas? Não sei como verificar.
3.4.3 Dependências de Software? Há Dependências inadequadas ou desatualizadas? Não sei como verificar.
3.5 [Meio Ambiente?]
3.5.1 Variáveis de Ambiente? Há configuração incorreta das variáveis de ambiente? Não sei como verificar.
3.6 [Medição?] Não se aplica neste caso.

4 ANÁLISE: Descobrir as causas fundamentais.
4.1 Analisar no item 3.3.3 a classe import mobi.stos.caixadosaber.util.CustomFont.
4.1.1 Por que não funcionou o método CustomFont.openSans().deriveFont(14f)?
4.1.2 Analisando o código da classe CustomFont, constatamos que o recurso "/font/OpenSans-Regular.ttf" não foi encontrado.
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package mobi.stos.caixadosaber.util;

import java.awt.Font;
import java.awt.FontFormatException;
import java.awt.GraphicsEnvironment;
import java.io.IOException;
import java.io.InputStream;

/**
 *
 * @author 
 */
public class CustomFont {

    private final static String OPEN_SANS = "/font/OpenSans-Regular.ttf";

    private static Font openSans;

    public static Font openSans() {
   
        try {
            InputStream stream = ClassLoader.getSystemClassLoader().getResourceAsStream(OPEN_SANS);
            openSans = Font.createFont(Font.TRUETYPE_FONT, stream);

            GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
            ge.registerFont(openSans);
            return openSans;
        } catch (IOException | FontFormatException e) {
            //Handle exception
            return null;
        }
    }
4.1.3 Por que o recurso não foi encontrado, se está no caminho "src/main/resources/font/OpenSans-Regular.ttf"?
4.1.4 Analisando o classpath, constatamos que está configurado assim: "<classpathentry kind="src" path="src/main/resources/font"/>"
4.1.5 Analisando o Build Path no Eclipse, constatamos que está configurado como abaixo:
CaixasDoSaber/src/main/resources/font
   Output folder: (Default output folder)
   Included:(All)
   Excluded: (None)
   Native library location: (None)
   Ignore optional compile problems: No
   Contains test sources: No
4.1.6 Por que o erro está acontecendo, se as configurações do recurso estão corretas, aparentemente?

COMANDO: Por favor, crie um Plano de Ação para resolver o problema especificado acima e execute as ações que puder, como, por exemplo, escreva um texto com qualquer codificação ou configuração necessária.

Resposta do Chatbot de IA

5 PLANO DE AÇÃO

5.1 Verifique o Build Path:
No Eclipse, clique com o botão direito no seu projeto "CaixasDoSaber" e selecione "Properties".
Vá para "Java Build Path" e certifique-se de que a pasta "src/main/resources" esteja listada na aba "Source".
Atenção: Verifique se a pasta "src/main/resources" está marcada como "Resources". Isso é crucial para que os arquivos dentro dela sejam tratados como recursos e incluídos no classpath durante a execução.

5.2 Verifique a Configuração de Execução (Run Configuration):
Clique com o botão direito no seu projeto e selecione "Run As" -> "Run Configurations...".
Selecione a configuração de execução do seu aplicativo Java.
Na aba "Classpath", verifique se a pasta "src/main/resources" está incluída. Se não estiver, adicione-a.

5.3 Caminho do Arquivo de Fonte:
Dentro da classe `CustomFont`, verifique se o caminho para o arquivo de fonte (`OPEN_SANS`) está correto. Certifique-se de que ele corresponda à estrutura de pastas dentro de "src/main/resources". Por exemplo, se o arquivo estiver em "src/main/resources/font/OpenSans-Regular.ttf", o caminho deve ser "/font/OpenSans-Regular.ttf".

5.4 Tratamento de Exceções:
Implemente o tratamento de exceções conforme o exemplo que forneci anteriormente. Isso ajudará a identificar se o problema é realmente a falta do arquivo de fonte ou outro erro.

5.5 Limpeza e Reconstrução do Projeto:
Às vezes, o Eclipse pode ter problemas com o cache. Tente limpar e reconstruir o projeto:
No menu "Project", selecione "Clean...".
Selecione seu projeto e clique em "OK".
No menu "Project", selecione "Build All".

5.6 Teste a Aplicação:
Execute a aplicação novamente e veja se o erro foi corrigido.
Observações Adicionais
Depuração: Se o erro persistir, use o modo de depuração do Eclipse para percorrer o código passo a passo e verificar o valor das variáveis. Isso pode ajudar a identificar a causa raiz do problema.
Console de Erros: Verifique o console do Eclipse para obter mensagens de erro mais detalhadas.
Fontes no Projeto: Certifique-se de que o arquivo "OpenSans-Regular.ttf" esteja realmente presente na pasta "src/main/resources/font" do seu projeto.

Seguindo estas etapas, você deverá conseguir identificar e corrigir o problema dentro do Eclipse, sem a necessidade de gerar o arquivo JAR. Lembre-se de que a verificação do Build Path e a marcação da pasta "src/main/resources" como "Resources" são cruciais neste caso.

Interações Adicionais com o Chatbot de IA

Foram necessárias interações para pedir mais ajuda na solução, por falta de conhecimento.
Segue abaixo a resposta a um pedido de ajuda para marcar a pasta resources como RECURSO.

No Eclipse, para marcar uma pasta como um "Resource" (recurso) no Build Path de um projeto, você precisa configurá-la como uma pasta de recursos, o que é útil para projetos Java, especialmente quando você deseja incluir arquivos não-Java (como XML, propriedades, imagens, etc.) no classpath do projeto. Abaixo está o passo a passo para fazer isso:

Passos para marcar uma pasta como Resource no Eclipse:

1 Crie ou identifique a pasta:
  Certifique-se de que a pasta que você deseja marcar como "Resource" já existe no projeto. Caso não exista, crie-a no diretório do projeto (por exemplo, uma pasta chamada resources).

2 Acesse as propriedades do projeto:
  Clique com o botão direito do mouse no projeto no "Project Explorer".
  Selecione a opção "Properties" no menu de contexto.

3 Navegue até o Build Path:
  Na janela de propriedades, vá para a seção "Java Build Path" no menu à esquerda.

4 Adicione a pasta como Source Folder (se aplicável):
  Na aba "Source", clique no botão "Add Folder".
  Na janela que abrir, localize e selecione a pasta que você deseja marcar como recurso (por exemplo, resources).
  Clique em OK para adicioná-la como uma "Source Folder". Isso faz com que os arquivos dentro dessa pasta sejam incluídos no classpath do projeto e tratados como recursos.

5 (Opcional) Configure a pasta como Resource Folder:
  Se você não deseja que a pasta seja tratada como uma "Source Folder" para código Java, mas apenas como uma pasta de recursos, você pode configurar o Eclipse para copiá-la diretamente para o diretório de saída (por exemplo, bin ou target).
  Para isso, na aba "Source", após adicionar a pasta, clique em "Edit" e configure a seção "Output folder" para o local onde os recursos devem ser copiados.

6 Confirme e aplique as alterações:
  Após configurar a pasta, clique em Apply e depois em Apply and Close para salvar as alterações.

7 Verifique o resultado:
  Os arquivos dentro da pasta agora estarão disponíveis no classpath do projeto e serão copiados para o diretório de saída durante o build. Você pode verificar isso observando o diretório de saída (geralmente bin ou target) ou testando o acesso aos recursos no código Java (por exemplo, usando ClassLoader.getResource()).

Observações importantes:

• Source Folder vs. Resource Folder: No Eclipse, as "Source Folders" são usadas tanto para código Java quanto para recursos. Se você adicionar uma pasta como "Source Folder", todos os arquivos não-Java (como .properties, .xml, etc.) serão automaticamente tratados como recursos e incluídos no classpath.

• Maven/Gradle: Se você estiver usando uma ferramenta de build como Maven ou Gradle, a pasta de recursos pode ser configurada diretamente no arquivo de configuração (pom.xml ou build.gradle), e o Eclipse geralmente reconhece essas configurações automaticamente (especialmente se você usar o plugin M2E para Maven).
  Exemplo no Maven: A pasta src/main/resources é automaticamente tratada como uma pasta de recursos.

• Filtros de exclusão/inclusão: Se você quiser incluir ou excluir arquivos específicos dentro da pasta de recursos, use a opção "Included" ou "Excluded" na configuração da pasta no Build Path.

Exemplo prático:

Se você tem uma pasta chamada resources no projeto e quer usá-la para armazenar arquivos de configuração:
1 Adicione resources como uma "Source Folder" no Build Path.
2 Coloque um arquivo, por exemplo, config.properties, dentro de resources.
3 No código Java, você pode acessar o arquivo como um recurso usando:
java
InputStream input = MinhaClasse.class.getClassLoader().getResourceAsStream("config.properties");

Resumo do Prompt e da Resposta 

Segue abaixo um resumo dos tópicos "Prompt Completo" e "Resposta do Chatbot de IA".

O objetivo é facilitar o entendimento do problema e da solução, sem os detalhes das etapas "Identificação do Problema", "Observação", "Análise" e "Plano de Ação", do MASP.

Entendendo o Problema

O erro em questão ocorreu na classe SplashUI.java, na linha 92, onde o código tenta definir a fonte de um rótulo (jLabel2) usando um objeto Font chamado openSans. A exceção NullPointerException indica que openSans é nulo neste momento.

Análise da Causa Raiz

Após uma análise minuciosa do código e das configurações do projeto, foi constatado que o problema está relacionado ao carregamento do arquivo de fonte "OpenSans-Regular.ttf". A classe CustomFont é responsável por carregar a fonte, mas o recurso não está sendo encontrado no caminho especificado.

Plano de Ação

Para resolver o erro, siga as etapas abaixo:

  1. Verifique o Build Path:
    • No Eclipse, clique com o botão direito no seu projeto "CaixasDoSaber" e selecione "Properties".
    • Vá para "Java Build Path" e certifique-se de que a pasta "src/main/resources" esteja listada na aba "Source".
    • Atenção: Verifique se a pasta "src/main/resources" está marcada como "Resources". Isso é crucial para que os arquivos dentro dela sejam tratados como recursos e incluídos no classpath durante a execução.
  2. Verifique a Configuração de Execução (Run Configuration):
    • Clique com o botão direito no seu projeto e selecione "Run As" -> "Run Configurations...".
    • Selecione a configuração de execução do seu aplicativo Java.
    • Na aba "Classpath", verifique se a pasta "src/main/resources" está incluída. Se não estiver, adicione-a.
  3. Caminho do Arquivo de Fonte:
    • Dentro da classe CustomFont, verifique se o caminho para o arquivo de fonte (OPEN_SANS) está correto. Certifique-se de que ele corresponda à estrutura de pastas dentro de "src/main/resources". Por exemplo, se o arquivo estiver em "src/main/resources/font/OpenSans-Regular.ttf", o caminho deve ser "/font/OpenSans-Regular.ttf".
  4. Tratamento de Exceções:
    • Implemente o tratamento de exceções na classe CustomFont para identificar se o problema é realmente a falta do arquivo de fonte ou outro erro.
  5. Limpeza e Reconstrução do Projeto:
    • No menu "Project", selecione "Clean...".
    • Selecione seu projeto e clique em "OK".
    • No menu "Project", selecione "Build All".
  6. Teste a Aplicação:
    • Execute a aplicação novamente e veja se o erro foi corrigido.

Observações Adicionais

  • Depuração: Se o erro persistir, use o modo de depuração do Eclipse para percorrer o código passo a passo e verificar o valor das variáveis. Isso pode ajudar a identificar a causa raiz do problema.
  • Console de Erros: Verifique o console do Eclipse para obter mensagens de erro mais detalhadas.
  • Fontes no Projeto: Certifique-se de que o arquivo "OpenSans-Regular.ttf" esteja realmente presente na pasta "src/main/resources/font" do seu projeto.

Conclusão

Seguindo este plano de ação, você deverá conseguir identificar e corrigir o problema dentro do Eclipse, sem a necessidade de gerar o arquivo JAR. Lembre-se de que a verificação do Build Path e a marcação da pasta "src/main/resources" como "Resources" são cruciais neste caso.


REVISÃO

Se você preferir vídeo, em vez de texto, assista clicando aqui.

Nos tópicos acima, foram apresentados:
  • Prompt elaborado conforme o MASP
  • Resposta do Chatbot de IA
  • Interações Adicionais para esclarecimentos
Algumas palavras-chave foram pintadas para destacar as técnicas usadas, e linhas em branco foram adicionadas para melhorar a leitura.

Sugerimos que o leitor copie este Prompt e cole no Chatbot de IA de sua preferência, para observar o Plano de Ação que será produzido.

Em seguida, o leitor poderá editar este texto de exemplo e alterar para resolver um problema, de qualquer área de conhecimento e não só de TI, conforme o exemplo.

Sugestões de melhoria neste Prompt serão muito bem-vindas.

CONCLUSÃO

Se você preferir vídeo, em vez de texto, assista clicando aqui.

O problema foi resolvido? SIM

Um desenvolvedor com experiência em Java, provavelmente, resolveria este problema em poucos minutos.

Mas é importante enfatizar que nós estávamos tentando fazer algo sem saber como, já que nosso conhecimento da tecnologia Java é pouco e a nossa experiência foi por um período curto, há vários anos.

Constatações:
  • Enquanto estávamos elaborando o Prompt, aprendemos um pouco, graças às perguntas de cada etapa do MASP, mas não o suficiente para resolver o problema;
  • É possível fazer sem saber, com MASP & IA;
  • É mais divertido aprender fazendo, com MASP & IA, do que lendo livros e tutoriais.


Demais Episódios da Temporada

Entendendo a Metáfora "Home Office é Moto Boy"

Dashboard de Produtividade Pessoal T1E13: BugCT1-5 Erro 400 no login

INTRODUÇÃO Post anterior:  Dashboard de Produtividade Pessoal T1E12: BugCT1-4 Código pronto para login com Google Identity Services (GIS) O ...