iMasters – We are Developers

Blog

  • API, JQuery e Segurança com CORS

    API, JQuery e Segurança com CORS

    Olá meu nome é Mauricio Junior e o hoje eu vou te mostrar sobre CORS. CORS significa (Cross-Origin Requests), isso quer dizer qualquer request precisa ser verificado para consumir a Api que você publicou. É importante verificar e desabilitar os endereços e ter um pouco de segurança para evitar que qualquer chamada de dados seja respondida.

    Eu vou mostrar como fazer uma chamada com JQuery para a sua Api.

    O C# e Api pode habilitar ou desabilitar as chamadas de forma automática. Para habiltiar e permitir que qualquer chamada seja aceita em sua Api, é necessário adicionar o AlowAnyHeader(), AllowAnyMethod() e AllowAnyOrigin() dentro do ConfigureServices método.

    public void ConfigureServices(IServiceCollection services)
{
    //add cors
    services.AddCors(options =>
    {
        options.AddPolicy("Policy", builder =>
        {
            builder
                .AllowAnyHeader()
                .AllowAnyMethod()
                .AllowAnyOrigin();
        });
    });
}


public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseCors("Policy");
}

    Código 1.1 

    Onde está o método ConfigureServices? Está dentro do Startup.cs ou Program.cs dependendo da versão que está utilizando.

    Eu tenho uma Api que retorna todos os cursos da plataforma.academy em meu localhost e quando eu tento acessar usando um simples JQuery, o acesso é cortado e para conseguir resolver esse problema, eu tive que permitir o acesso usando o código 1.1.

    No código 1.2 eu mostro como fazer a chamada usando JQuery para pegar os dados da Api criada por mim.

    <!DOCTYPE html>  
<html>  
<head>  
<title>Courses</title>  
<meta charset="utf-8" />  
<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.8.3/jquery.min.js"></script>  


<script type="text/javascript">  
    $(document).ready(function () {               
            $.ajax({  
                type: "GET",  
                url: "https://localhost:5001/api/course", 
                contentType: "application/json; charset=utf-8",  
                dataType: "json",  
                success: function (response) {  


                    //Clear all previous list of members  
                    $("#Courses").empty();  


                    //Display Asp.Net Web API response in console log   
                    //You can see console log value in developer tool   
                    //by pressing F12 function key.  
                    console.log(response);  

                    // Variable created to store <li>Memeber Detail</li>  
                    var ListValue = "";  


                    //Variable created to iterate the json array values.  
                    var i;  

                    //Generic loop to iterate the response arrays.  
                    for (i = 0; i < response.length; ++i) {  
                        ListValue += "<li>" + response[i].title + " --- " + response[i].courseLink  
                    }  


                    //Add/Append the formatted values of ListValue variable into ID called "Courses"  
                    $("#Courses").append(ListValue);  
                },  
                failure: function (response) {  
                    alert(response.responseText);  
                    alert("Failure");  
                },  
                error: function (response) {  
                    alert(response);  
                    alert("Error");  
                }  
       });  
    });  
</script>  
</head>
<body>  
    <h2>Plataforma.Academy</h2>        
    <ul id="Courses">  
    </ul>  
</body>  
</html>

    Código 1.2

    No código 1.3 eu mostro o Json que a Api vai retornar mas no momento eu vou usar apenas as propriedades chamadas title e courseLink.

    [
  {
    "title": "string",
    "courseLink": "string",
    "status": "string",
    "imageCourse": "string",
    "courseCategoryId": 0,
    "courseDescription": "string",
    "coursePrice": "string",
    "courseOldPrice": "string",
    "courseCategoyLink": "string"
  }
]

    Código 1.3 

    Sem as propriedades alteradas dentro da configuração da Api, quando o HTML, JavaScript e JQuery tentam acessar o endereço, um erro é retornado para o JavaScript que pode ser visto dentro do log.

    [Error] Origin null is not allowed by Access-Control-Allow-Origin. Status code: 204

    [Error] XMLHttpRequest cannot load https://localhost:5001/api/course due to access control checks.

    [Error] Failed to load resource: Origin null is not allowed by Access-Control-Allow-Origin. Status code: 204 (course, line 0)

    Note que as mensagens mostram claramente sobre a permissão de acesso original. Tenha em mente autorizar apenas endereços conhecidos por você ou pelo seu sistema. Para adicionar diferentes endereços no CORS, é necessário fazer conforme o código 1.4.

    //add cors
services.AddCors(options =>
{
    options.AddPolicy("Policy", builder =>
    {
        builder.WithOrigins("https://plataforma.academy", "site2", "site3");
    });
});

    Código 1.4.

    Veja o resultado da página HTML consumindo a Api.

    Qualquer dúvida pode entrar em contato comigo pelo meu site www.mauriciojunior.net ou pode acessar diretamente os cursos da escola de programação academy https://plataforma.academy

     

     

     

     

     

     

  • Construindo um Mecanismo de Circuit Breaker Utilizando .NET

    Construindo um Mecanismo de Circuit Breaker Utilizando .NET

    Introdução ao Padrão Circuit Breaker

    O padrão Circuit Breaker é uma técnica utilizada no desenvolvimento de software para aumentar a resiliência de aplicações, especialmente em arquiteturas distribuídas (PUNITHAVATHY; PRIYA, 2024). Esse padrão atua como um interruptor que impede que chamadas a serviços falhem repetidamente, permitindo que o sistema se recupere antes de tentar uma nova chamada. Isso é especialmente útil em cenários onde a latência e a falha de serviços externos podem impactar a performance da aplicação. Em essência, o Circuit Breaker ajuda a evitar que um sistema inteiro falhe devido a problemas em um único componente.

    Propósito

    O Circuit Breaker é inspirado nos sistemas elétricos, onde um circuito pode ser interrompido para evitar sobrecargas. No contexto de software, ele funciona de maneira semelhante, permitindo que o sistema “desligue” as chamadas a um serviço que está falhando (PUNITHAVATHY; PRIYA, 2024). Isso evita que falhas em um serviço afetem todo o sistema, permitindo que ele se recupere antes de retomar as operações normais (FOWLER, 2014). Dessa forma, podemos considerar que o Circuit Breaker é:

    • Um mecanismo que previne chamadas repetidas a serviços instáveis, protegendo o sistema de falhas em cascata.
    • Inspirado em disjuntores elétricos, “abrindo” o circuito quando detecta falhas contínuas.
    • Composto por três estados: Closed (normal), Open (chamadas bloqueadas) e Half-Open (teste para retomar operações) (POLLY, 2023).
    • Utilizado para melhorar a estabilidade e resiliência de aplicações distribuídas (MICROSOFT, 2025).

    Da mesma forma, é importante entender que o Circuit Breaker não é:

    • Um mecanismo de retry simples: embora possa ser combinado com retries, sua função principal é interromper chamadas a serviços problemáticos.
    • Um substituto para fallback: embora possa ser usado em conjunto com estratégias de fallback, eles têm propósitos distintos.
    • Uma ferramenta de monitoramento: embora forneça informações sobre falhas, não substitui sistemas de observabilidade.
    • Balanceador de carga: sua função é interromper chamadas a serviços instáveis, não distribuir tráfego entre serviços saudáveis.

    Por Que Usar Circuit Breaker?

    Quando um serviço externo falha, as chamadas subsequentes a esse serviço podem causar sobrecarga e latência desnecessárias, levando a um efeito cascata que pode comprometer a estabilidade da aplicação (COSTA et al., 2022). O padrão Circuit Breaker ajuda a evitar essa situação, protegendo a aplicação de falhas em cascata. Ele permite que a aplicação reaja rapidamente a problemas, liberando recursos e permitindo que o sistema se recupere mais rapidamente. Além disso, o Circuit Breaker pode ser configurado para fornecer feedback ao usuário, como mensagens de erro amigáveis, em vez de falhas silenciosas ou mensagens de erro genéricas.

    Em um mundo onde a dependência de serviços externos é cada vez mais comum, a implementação de um Circuit Breaker se torna uma prática recomendada (COSTA et al., 2022). Ele não só melhora a resiliência da aplicação, mas também facilita o monitoramento e a manutenção do sistema, permitindo que as equipes de desenvolvimento identifiquem rapidamente problemas que podem surgir devido a falhas externas.

    Implementando Circuit Breaker em .NET

    Para implementar um mecanismo de Circuit Breaker em .NET, podemos usar a biblioteca Polly, que é uma biblioteca de resiliência para .NET que facilita a implementação de padrões como retry, timeout e circuit breaker. O Polly fornece uma API poderosa e flexível, permitindo que os desenvolvedores configurem políticas de resiliência que atendam às necessidades específicas de suas aplicações (PUNITHAVATHY; PRIYA, 2024).

    Instalação do Polly

    Para começar a usar o Polly, devemos instalar o pacote Polly via NuGet (POLLY, 2023). Isso pode ser feito através do console do NuGet com o seguinte comando:

    Install-Package Polly

    Alternativamente, você pode instalar o Polly utilizando o gerenciador de pacotes do Visual Studio. Basta procurar por “Polly” na seção de pacotes NuGet e clicar em instalar. Uma vez que o Polly está instalado, você pode começar a implementar suas políticas de resiliência em sua aplicação.

    Configurando o Circuit Breaker

    Após a instalação, podemos configurar um Circuit Breaker. O código a seguir demonstra como criar uma política de Circuit Breaker que abre o circuito após 3 falhas consecutivas e o mantém aberto por 30 segundos. Essa configuração é um ponto de partida e pode ser ajustada de acordo com as necessidades específicas de sua aplicação.

    using Polly;
using System;
using System.Net.Http;
using System.Threading.Tasks;

public class CircuitBreakerExample
{
    private static readonly HttpClient httpClient = new HttpClient();
    
    public async Task<string> FetchDataAsync(string url)
    {
        var circuitBreakerPolicy = Policy
            .Handle<HttpRequestException>()
            .CircuitBreaker(3, TimeSpan.FromSeconds(30));

        try
        {
            return await circuitBreakerPolicy.ExecuteAsync(async () => 
            {
                var response = await httpClient.GetAsync(url);
                response.EnsureSuccessStatusCode();
                return await response.Content.ReadAsStringAsync();
            });
        }
        catch (BrokenCircuitException)
        {
            return "Circuit is open. Please try again later.";
        }
    }
}

     

    Neste exemplo, estamos usando a política de Circuit Breaker do Polly para definir que, se ocorrerem três falhas consecutivas ao tentar acessar um URL, o circuito será aberto e permanecerá assim por 30 segundos. Durante esse tempo, qualquer tentativa de acesso ao serviço resultará em uma exceção BrokenCircuitException, que pode ser tratada para informar ao usuário que o serviço está temporariamente indisponível.

    Testando o Circuit Breaker

    Para testar o comportamento do Circuit Breaker, você pode simular chamadas a um serviço que falha. Aqui está um exemplo de como você poderia escrever um teste simples para verificar se o Circuit Breaker está funcionando conforme o esperado:

    public async Task TestCircuitBreaker()
{
    var circuitBreakerExample = new CircuitBreakerExample();
    
    for (int i = 0; i < 10; i++)
    {
        var result = await circuitBreakerExample.FetchDataAsync("http://example.com/fail");
        Console.WriteLine(result);
    }
}

    Neste teste, estamos chamando um serviço que sabemos que falhará. Após três falhas, o Circuit Breaker deve abrir e as tentativas subsequentes de chamada ao serviço devem resultar na mensagem “Circuit is open. Please try again later.” sendo impressa no console. Isso confirma que o Circuit Breaker está funcionando conforme o esperado e que está protegendo a aplicação de sobrecargas desnecessárias.

    Monitorando o Circuit Breaker

    Monitorar o estado do Circuit Breaker é crucial para entender o desempenho da sua aplicação. O Polly permite que você registre eventos de estado do Circuit Breaker, o que pode ser extremamente útil para depuração e manutenção. Aqui está um exemplo de como fazer isso:

    var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .CircuitBreaker(
        handledEventsAllowedBeforeBreaking: 3,
        durationOfBreak: TimeSpan.FromSeconds(30),
        onBreak: (exception, breakDelay) =>
        {
            Console.WriteLine(
            $"[OPEN] Circuit opened due to: {exception.Message}. Waiting {breakDelay.TotalSeconds} seconds before retrying.");
        },
        onReset: () =>
        {
            Console.WriteLine(
            "[CLOSED] Circuit closed. Operations resumed successfully.");
        },
        onHalfOpen: () =>
        {
            Console.WriteLine(
            "[HALF-OPEN] Circuit is half-open. Testing service availability...");
        });

    Neste exemplo, estamos adicionando dois manipuladores de eventos: um para quando o circuito é aberto (onBreak) e outro para quando o circuito é redefinido (onReset). Esses eventos permitem que você registre informações sobre o estado do Circuit Breaker, ajudando a identificar padrões de falhas e a ajustar as configurações conforme necessário.

    Conclusão

    O padrão Circuit Breaker contribui no aumento da resiliência de aplicações .NET. Usando a biblioteca Polly, é possível implementar essa técnica de forma simples e eficiente. Monitorar o estado do Circuit Breaker e ajustar suas configurações são passos fundamentais para garantir que sua aplicação continue a funcionar de maneira confiável, mesmo em face de falhas externas. Ao integrar o Circuit Breaker em sua estratégia de desenvolvimento, você estará proporcionando uma base mais robusta e segura para suas aplicações, melhorando a experiência do usuário e a confiabilidade do sistema a longo prazo.

    Referências

    • PUNITHAVATHY, E.; PRIYA, N. Comparative Study of Static Resilience Patterns Over Dynamically Modified Resilience Patterns. 2024.
    • PUNITHAVATHY, E.; PRIYA, N. Auto retry circuit breaker for enhanced performance in microservice applications. International Journal of Electrical & Computer Engineering (2088-8708), v. 14, n. 2, 2024.
    • COSTA, Thiago M. et al. Avaliação de Desempenho de Dois Padrões de Resiliência para Microsserviços: Retry e Circuit Breaker. In: Simpósio Brasileiro de Redes de Computadores e Sistemas Distribuídos (SBRC). SBC, 2022. p. 517-530.
    • POLLY, GitHub. Polly: The .NET resilience and transient-fault-handling library. Disponível em: https://www.pollydocs.org . Acesso em: 15 abril. 2025.
    • FOWLER, M. Circuit Breaker. 2014. Disponível em https://martinfowler.com/bliki/CircuitBreaker.html. Acesso em: 15 abril. 2025.
    • MICROSOFT. Circuit Breaker pattern. Disponível em https://learn.microsoft.com/en-us/azure/architecture/patterns/circuit-breaker. Acesso em: 15 abril. 2025.
  • Arquitetura Hexagonal na prática com exemplos em Python

    Arquitetura Hexagonal na prática com exemplos em Python

    A arquitetura hexagonal, também conhecida como Ports and Adapters, é uma abordagem de design de software que separa a lógica central da aplicação (o “core”) das suas interfaces externas. Essa separação facilita a manutenção, testes automatizados e a evolução da aplicação ao longo do tempo.

    Neste artigo, você vai entender:

    • O que é arquitetura hexagonal
    • Como ela se diferencia de outros padrões
    • Como aplicar o conceito em Python
    • Exemplos de código com repositório, serviços e controladores

    ✅ O que é arquitetura hexagonal?

    Criada por Alistair Cockburn, a arquitetura hexagonal propõe que o sistema tenha uma lógica de negócio isolada, acessada por “portas” (interfaces). As dependências externas — como banco de dados, interfaces web, filas ou outros serviços — se conectam ao core por meio de “adaptadores”.

    Benefícios principais:

    • Baixo acoplamento entre lógica de negócio e tecnologias
    • Testes mais fáceis (mock de adaptadores)
    • Flexibilidade para trocar implementações (por exemplo, SQLite → PostgreSQL)

    🧠 Estrutura geral

             [Adaptador Web]   [CLI]   [Message Queue]
                 \           |           /
                  \          |          /
                [Portas de entrada - Application Services]
                           ↓
                [Core - Regras de Negócio]
                           ↑
                [Portas de saída - Interfaces]
                 /          |          \
        [DB adapter]   [API externa]   [Cache]

    📦 Exemplo prático em Python

    Vamos simular um sistema simples de cadastro de usuários, seguindo arquitetura hexagonal.

    1. Entidade de domínio (core/domain/user.py)

    from dataclasses import dataclass

@dataclass
class User:
    id: int
    name: str
    email: str

    2. Porta de saída (core/ports/user_repository.py)

    from abc import ABC, abstractmethod
from core.domain.user import User

class UserRepository(ABC):

    @abstractmethod
    def save(self, user: User) -> None:
        pass

    @abstractmethod
    def get_by_id(self, user_id: int) -> User:
        pass

    3. Serviço de aplicação (core/services/user_service.py)

    from core.domain.user import User
from core.ports.user_repository import UserRepository

class UserService:

    def __init__(self, repository: UserRepository):
        self.repository = repository

    def create_user(self, id: int, name: str, email: str):
        user = User(id=id, name=name, email=email)
        self.repository.save(user)

    def get_user(self, user_id: int) -> User:
        return self.repository.get_by_id(user_id)

    4. Adaptador de saída com SQLite (infra/sqlite_user_repository.py)

    import sqlite3
from core.domain.user import User
from core.ports.user_repository import UserRepository

class SQLiteUserRepository(UserRepository):

    def __init__(self, db_path: str = ":memory:"):
        self.conn = sqlite3.connect(db_path)
        self.conn.execute("CREATE TABLE IF NOT EXISTS users (id INTEGER, name TEXT, email TEXT)")
        self.conn.commit()

    def save(self, user: User) -> None:
        self.conn.execute("INSERT INTO users (id, name, email) VALUES (?, ?, ?)", 
                          (user.id, user.name, user.email))
        self.conn.commit()

    def get_by_id(self, user_id: int) -> User:
        cursor = self.conn.execute("SELECT id, name, email FROM users WHERE id = ?", (user_id,))
        row = cursor.fetchone()
        if row:
            return User(id=row[0], name=row[1], email=row[2])
        else:
            raise Exception("User not found")

    5. Adaptador de entrada: interface via CLI (main.py)

    from core.services.user_service import UserService
from infra.sqlite_user_repository import SQLiteUserRepository

if __name__ == "__main__":
    repo = SQLiteUserRepository()
    service = UserService(repository=repo)

    service.create_user(1, "Rafa", "rafa@example.com")
    user = service.get_user(1)
    print(user)

    🧪 E os testes?

    Graças à separação entre a lógica de negócio e os adaptadores, você pode testar o UserService usando mocks do UserRepository, sem necessidade de banco de dados real. Exemplo com unittest.mock:

    from unittest.mock import MagicMock
from core.services.user_service import UserService
from core.domain.user import User

def test_create_user():
    mock_repo = MagicMock()
    service = UserService(repository=mock_repo)
    
    service.create_user(1, "Teste", "teste@example.com")
    
    mock_repo.save.assert_called_once_with(User(id=1, name="Teste", email="teste@example.com"))

     

    🚀 Conclusão

    A arquitetura hexagonal é uma excelente escolha para quem busca construir aplicações com alta coesão e baixo acoplamento. Ela promove uma separação clara entre as regras de negócio e as interfaces externas, permitindo que o desenvolvedor mantenha o foco no que realmente importa: a lógica central da aplicação.

    Ao isolar o core da infraestrutura, fica mais fácil adaptar a aplicação a novas tecnologias — como trocar o banco de dados, mudar de framework web ou até adicionar uma API pública — sem precisar reescrever as regras de negócio. Isso significa menos retrabalho, mais testes automatizados e mais estabilidade em produção.

    Além disso, essa abordagem encaixa perfeitamente com outras práticas modernas de engenharia de software, como TDD (Test-Driven Development), Clean Architecture e DevOps. Em contextos corporativos, a adoção da arquitetura hexagonal pode ajudar a lidar melhor com equipes grandes, rotatividade de devs e projetos de longa duração.

    Se você ainda não aplica esse padrão, vale a pena começar com um projeto menor e experimentar na prática. Com o tempo, os benefícios em manutenção, testes e escalabilidade vão ficar evidentes.

    Segue aqui o nosso Diagrama de Arquitetura Hexagonal

    Hexagonal Architecture Diagram Template ...

    Este diagrama mostra:

    • Domínio (Core): onde reside a lógica de negócio da aplicação.
    • Portas: interfaces que definem como o core se comunica com o mundo externo.
    • Adaptadores: implementações concretas que conectam as portas a sistemas externos, como bancos de dados, interfaces web, filas de mensagens, etc.

    Você pode explorar e personalizar este modelo interativo no Visual Paradigm Online.

    Até a próxima, pessoal!

  • A Responsabilização pelo Uso Indevido de Deepfakes: Panorama Legal no Brasil e nos Estados Unidos

    A Responsabilização pelo Uso Indevido de Deepfakes: Panorama Legal no Brasil e nos Estados Unidos

    O avanço acelerado da inteligência artificial tem promovido inovações significativas em diversos setores, mas também trouxe consigo desafios complexos, especialmente no campo jurídico. Dentre as diversas aplicações controversa das chamadas deepfakes , estão, por exemplo, o uso para finalidade de propagar conteúdo íntimo falsificado ou para manipular a percepção pública.

    Nesses e em outros casos de uso indevido desta tecnologia os impactos sobre a privacidade, honra e dignidade das vítimas podem ser devastadores. Diante desse cenário, legisladores em diversos países vêm reagindo com propostas específicas de criminalização.

    Este artigo examina a tendência de responsabilização penal para usos lesivos de deepfakes, com foco nas recentes alterações legislativas ocorridas no Brasil e nos Estados Unidos. 

    O que são deepfakes e quando seu uso é juridicamente aceitável? 

    Deepfake é a designação atribuída a materiais digitais — vídeos, imagens ou áudios — manipulados com o auxílio de algoritmos de inteligência artificial, capazes de simular com impressionante fidelidade rostos humanos, vozes e comportamentos. A tecnologia permite, por exemplo, fazer com que uma pessoa aparente dizer ou fazer algo que nunca ocorreu de fato, com aparência extremamente verossímil. 

    Apesar de sua notoriedade estar frequentemente ligada a usos indevidos, como chantagens, pornografia não consentida ou campanhas de desinformação, a tecnologia também pode ser empregada de forma lícita e benéfica.  

    Entre as aplicações legítimas estão produções artísticas e cinematográficas; treinamentos; reconstituições históricas; ferramentas de acessibilidade além de campanhas publicitárias. 

    Para que o uso de uma deepfake seja considerado compatível com o ordenamento jurídico, é necessário que a utilização respeite os direitos fundamentais à imagem, à honra e à privacidade, bem como as normas de proteção de dados pessoais. Em certos contextos, o consentimento expresso da pessoa representada será obrigatório; em outros, como na paródia ou sátira, o uso poderá ser legítimo mesmo sem autorização, desde que respeitados os limites legais e os princípios da boa-fé. Em suma, a licitude do uso da tecnologia dependerá sempre da análise contextual, levando-se em consideração o propósito, o meio de difusão e os efeitos do material gerado. 

    Brasil: Repercussões da nova redação do artigo 147-B do Código Penal 

    O legislador brasileiro reconheceu o impacto da tecnologia deepfake na dinâmica de violência de gênero, especialmente nos casos em que mulheres são alvo de violência psicológica por meio da disseminação de conteúdo falso envolvendo suas imagens ou vozes. 

    Em 2025, foi aprovada a Lei nº 15.123, que alterou o artigo 147-B do Código Penal, dispositivo que trata da violência psicológica contra a mulher. A inovação legislativa introduziu uma causa de aumento de pena quando o crime for cometido mediante o uso de inteligência artificial, ou de outros recursos tecnológicos que resultem na adulteração da imagem ou da voz da vítima. O acréscimo na pena reforça a gravidade da prática e busca coibir, de forma mais contundente, condutas que atentem contra a integridade emocional e a imagem da mulher a partir do mau uso de determinados recursos tecnológicos. 

    Estados Unidos: A criação do Take It Down Act 

    Nos Estados Unidos, o debate legislativo também avançou diante do crescimento de casos envolvendo deepfakes de caráter íntimo e não consentido. Em abril de 2025, o Congresso americano aprovou o Take It Down Act — um marco legislativo bipartidário voltado para a responsabilização penal da divulgação de imagens íntimas adulteradas ou produzidas por IA. 

    A legislação estabelece obrigações específicas para as plataformas digitais, que devem remover o conteúdo denunciado em até 48 horas.  

    Àquele que realizou a produção ou alteração da imagem, são previstas penas de até dois anos de prisão, pena que se estende a três anos se a imagem manipulada envolver menores de idade.  

    O texto legal também recebeu apoio de figuras públicas e defensores dos direitos digitais, sendo visto como uma resposta institucional à vulnerabilidade enfrentada, sobretudo, por mulheres e adolescentes nesse contexto. 

    Considerações finais 

    O surgimento de tecnologias capazes de simular a realidade com tamanha precisão impõe ao Direito o desafio de acompanhar, de forma célere e eficaz, os impactos sociais e individuais decorrentes dessas inovações. Tanto a legislação brasileira quanto a norte-americana demonstra uma tendência de fortalecimento das ferramentas penais para conter os danos provocados por deepfakes abusivos. 

    No entanto, é fundamental que essas normas sejam acompanhadas de diretrizes claras que evitem excessos punitivos e garantam a compatibilidade com os direitos constitucionais à liberdade de expressão e à informação. Mais do que criminalizar, é preciso desenvolver uma cultura de uso responsável da tecnologia, que combine prevenção, educação digital e responsabilização proporcional. 

    O enfrentamento aos riscos das deepfakes exige, portanto, não apenas instrumentos legais robustos, mas também o engajamento coordenado de governos, plataformas tecnológicas, operadores do Direito e da sociedade civil. 

  • GitHub Copilot: 5 recursos essenciais e como começar a usar

    GitHub Copilot: 5 recursos essenciais e como começar a usar

    Autocompletar código, revisões por IA, análises de segurança e chats integrados são alguns dos recursos que o GitHub Copilot traz ao trabalho diário das pessoas desenvolvedoras

    Imagine ter um par que nunca faz pausas e conhece muitas linguagens de programação. Esse é o Copilot, alimentado por vários grandes modelos de linguagem (LLMs), que podem ser selecionados por você. Inicialmente anunciada em junho de 2021, essa tecnologia se tornou rapidamente a ferramenta de programação baseada em IA mais amplamente adotada pela indústria, ajudando profissionais a terem mais tempo para focar em novos recursos e tarefas criativas adicionais.

    O GitHub Copilot, fiel ao seu nome, serve como um assistente confiável para tarefas diárias. Por ele, é possível gerar código a partir de prompts em linguagem natural, interpretar comandos shell, resumir alterações em pull requests, depurar e refatorar códigos, apenas para citar algumas possibilidades. Esse programador parceiro, baseado em IA, está disponível em plataformas como VS Code, Visual Studio, JetBrains IDEs, Neovim, XCode e GitHub Mobile, além de terminais e no github.com. O sistema oferece suporte a uma ampla gama de linguagens de programação e foi projetado para auxiliar pessoas desenvolvedoras de todos os níveis.

    Estudantes, educadores e mantenedores de projetos de código aberto também têm acesso gratuito ao Copilot Pro, com ainda mais recursos, enquanto organizações podem assinar os planos Business e Enterprise. No entanto, qualquer pessoa pode experimentar o assistente gratuitamente, baixando e instalando diretamente do GitHub para o IDE de sua escolha.

    O GitHub Copilot funciona com diversos IDEs do mercado, mas, neste artigo, vamos focar nos dois mais populares: VS Code e JetBrains.

    Como instalar o GitHub Copilot no VS Code

    1. Acesse o Marketplace de Extensões e procure por “GitHub Copilot”. Clique na extensão do GitHub Copilot, criada pelo GitHub, e selecione Instalar para baixar dois complementos, o GitHub Copilot e GitHub Copilot Chat;

    2. Uma vez instalados, entre no VS Code selecionando o menu “Contas” na Barra de Atividade, e faça login em sua conta no GitHub que tem acesso ao GitHub Copilot, autorizando o acesso se necessário.

    Pronto! Ao retornar ao editor, você notará um ícone do Copilot no topo, ao lado do Centro de Comando, e o mesmo símbolo na barra na parte inferior da janela. Ao clicar nele, você verá um pedido de seleção sobre qual conta deseja usar. Depois disso, um menu vai aparecer e o status indicará que a configuração foi concluída.

    Como instalar o GitHub Copilot no IDE JetBrains

    Usaremos PyCharm para instalar o GitHub Copilot no IDE JetBrains. Veja como:

    1. Abra seu editor e acesse o marketplace de plugins. Procure por “GitHub Copilot” e clique em instalar, reiniciando seu IDE na sequência;

    2. Ao abrir um projeto, você irá notar um ícone do Copilot no lado direito de seu editor e também embaixo, com o status de “pronto”. Na sequência, verá dois ícones à esquerda, um relacionado ao GitHub Copilot (com um ponto de interrogação) e outro de chat. Dessa forma, a instalação está concluída.

    Você pode começar a usar o GitHub Copilot no JetBrains selecionando o primeiro ícone, GitHub Copilot com um ponto de interrogação, para obter uma visão geral, junto de uma mensagem de boas-vindas. Selecione o segundo ícone, GitHub Copilot com um ícone de chat, para buscar ajuda para dúvidas relacionadas à programação.

    É importante lembrar que, na primeira vez que abrir o assistente ou o chat, será necessário autorizar o acesso. Isso pode ser feito diretamente no editor, clicando no ícone e fazendo login com sua conta do GitHub. Conceda as permissões necessárias e, quando voltar, verá uma saudação confirmando que tudo está funcionando corretamente.

    Comece a trabalhar com 5 recursos essenciais do GitHub Copilot

    1. Códigos autocompletados

    Usaremos o exemplo simples de um jogo de Pedra, Papel e Tesoura, criado em Python, para mostrar como o GitHub Copilot pode gerar código usando linguagem natural. Primeiro, crie um novo arquivo chamado rock_paper_scissor.py. No topo do arquivo, adicione o seguinte comentário: “Crie um jogo de Pedra, Papel e Tesoura em que o usuário insira sua escolha e jogue contra o computador, que seleciona aleatoriamente sua ação, com o game mostrando quem venceu cada rodada. Adicione um contador de pontuação que conta as vitórias do jogador e do computador e permita que o jogo continue até o jogador digitar ‘quit’.”

    Pressione a tecla Enter algumas vezes. Você notará um texto cinza, em itálico, aparecendo após o cursor. Isso é chamado de ghost text e são as sugestões fornecidas pelo GitHub Copilot; é preciso pressionar Tab para aceitá-las. Continue fazendo isso até que a sugestão defina uma função (ou seja, comece com a palavra-chave def).

    Ao pressionar a tecla Enter após a definição da função, você verá um ghost text definindo a função principal. Passe o cursor sobre ele para visualizar diferentes opções disponíveis no menu. É possível aceitar uma única palavra, percorrer sugestões com a tecla Tab ou aceitar a sugestão atual. Também é possível clicar nos três pontos e selecionar “Abrir painel de sugestões”.

    O Painel de sugestões exibe uma lista com várias maneiras de implementar esse código. Observe as opções e escolha qual delas deseja usar. Depois, clique no botão “Aceitar sugestão” para adicionar o código ao seu arquivo.

    Por fim, adicione uma linha para invocar a função. Lembre-se de que, como o Copilot é uma IA generativa, ele nem sempre fornecerá as mesmas sugestões, ainda que com o mesmo prompt! Após adicionar o código, abra seu terminal e digite python rock_paper_scissor.py para jogar. Experimente o quanto quiser e digite quit quando decidir parar.

    2. Copilot Chat e chat integrado

    Há duas maneiras de usar a linguagem natural para interagir com o Copilot diretamente de seu IDE. No chat integrado, você pode selecionar uma linha de código e abrir uma janela de opções, usando prompts e diferentes modelos de IA compatíveis com o sistema para receber sugestões de código e respostas.

    Usando os ícones, as alterações podem ser aplicadas diretamente ao código — sem necessidade de copiar e colar! —, inseri-las no Terminal ou em um Novo Arquivo, fazer uma captura de tela ou copiar o código gerado. No topo do arquivo, estarão opções para aceitar as alterações, descartá-las, mostrá-las ou ocultá-las. Clique em Aceitar Alterações para que o editor finalize as mudanças. Depois, é hora de executar o código para ver as modificações em ação!

    O Copilot Chat também pode ser usado para adicionar contexto à programação, com a pessoa desenvolvedora indicando seus objetivos específicos ou fornecendo informações detalhadas ao assistente. Por exemplo, você pode usar a variável #file para especificar um arquivo ou arquivos que o Copilot deve utilizar ao resolver seu prompt, ou pode digitar #codebase para buscar em toda a sua base de código.

    Da mesma forma, é possível adicionar determinadas especialidades ao chat. Para chamar, digite @ na janela de chat seguido pelo nome do participante desejado. Por exemplo, @workspace chama um participante que tem conhecimento sobre todo o seu workspace. Isso pode ser útil para encontrar onde uma função está definida no seu projeto ou para gerar um README detalhado sobre o seu projeto.

    Outro participante que é frequentemente usado é o @terminal, que tem o contexto de toda a informação da janela de terminal integrada ao VS Code. Talvez o mais comum de todos seja @github, com conhecimento de seu repositório, pull requests, issues e a possibilidade de buscar na web.

    1. Comandos de barra (slash)

    Este é um recurso projetado para simplificar a experiência da pessoa desenvolvedora no uso do GitHub Copilot. Os comandos de barra (slash) funcionam como atalhos práticos para prompts frequentemente usados e úteis em tarefas do dia a dia. Dentro de uma janela do Copilot Chat, eles podem ser utilizados para realizar ações como explicar código, solucionar e corrigir erros, criar novos notebooks e muito mais.

    Basta digitar uma barra ( / ) no Copilot Chat para obter uma lista de comandos possíveis, que incluem desde explicações completas de código até revisões, testes, depuração e correções. Para ver a lista completa de comandos disponíveis, basta digitar /help ou consultar o cheat sheet do GitHub Copilot, onde estarão os prompts disponíveis no seu IDE de escolha.

    1. Copilot Edits

    Em uma das adições mais recentes ao GitHub Copilot, pessoas desenvolvedoras podem iniciar rapidamente uma sessão de iteração sobre mudanças de código, usando linguagem natural. Assim, é possível editar vários arquivos ao mesmo tempo e combinar o fluxo de conversa do Copilot Chat com o retorno rápido do chat integrado, reunindo tudo em uma única experiência.

    A opção Copilot Edit pode ser encontrada no menu do Copilot. Insira o prompt desejado, escolha o modelo que deseja usar e veja o assistente transmitir respostas para sua aprovação. Clique em “Aceitar” para adicionar as alterações ao seu código ou revise as sugestões, adicionando linhas ou fazendo modificações manualmente.

    1. Revisão de códigos (Code review)

    É possível levar todos esses recursos um passo adiante e deixar o Copilot revisar seu código antes de enviá-lo ao restante da equipe. Para fazer isso, selecione uma seção de código no seu editor. Um ícone de brilho aparecerá no canto superior esquerdo da seção destacada. Clique nesse ícone e selecione a opção “Revisar usando Copilot”.

    O GitHub Copilot oferece uma revisão inicial do seu código, ajudando a garantir qualidade e evitar bugs ou erros. Se preferir, você também pode acessar essa revisão do Copilot diretamente pelo github.com.

    É importante lembrar: o GitHub Copilot está aqui para te ajudar. A tecnologia foi projetada para aumentar sua produtividade e apoiar seu fluxo de trabalho, mas não para substituir sua experiência. Como qualquer ferramenta, é fundamental revisar as sugestões cuidadosamente e usá-las como um ponto de partida — deixando as decisões estratégicas para a pessoa desenvolvedora. Bom trabalho! ♦

    LEIA TAMBÉM

  • Como fazer o link chamar seu aplicativo?

    Como fazer o link chamar seu aplicativo?

    Olá pessoal, meu nome é Mauricio Junior e hoje eu vou falar de um problema que eu tive para fazer o meu aplicativo abrir um link do e-mail ou de um website. Sim, eu precisava abrir um link diretamente do meu website ou e-mail chamando o aplicativo instalado no device do cliente ou usuário.

    Nesse exemplo passo a passo eu mostro, usando a tecnologia MAUI e linguagem C# da Microsoft.

    Problema

    • Dificuldades de fazer um link chamar meu aplicativo;
    • Dificuldades de pegar os parâmetros passados pelo link

    A maioria dos artigos, vídeos e fóruns na Internet só mostra como fazer usando deeplink que é uma técnica que envolve alterar o website da empresa, colocar um artigo no servidor e identificar que você é o dono do host do site. Isso tudo poderia demorar meses para terminar quando você trabalha para uma grande empresa. Essa solução não iria servir para mim de jeito nenhum. Fora que são muitos passos para fazer até que de certo.

    Eu gostaria de uma coisa mais direta como o applink. Tem como fazer isso usando outra técnica sem muita complicação.

    Solução

    • Faz o applink mas não tem pessoas mostrando isso na Internet, nem em fóruns, nem em artigos e nem em vídeos.

    Eu vou mostrar aqui nesse artigo o passo a passo para fazer o seu aplicativo Android e iOS pegar ser chamado, pegar os dados e processar o que você queira. Esse artigo eu vou te mostrar como fazer para Android e iOS.

    iOS

    1 – Para iOS é necessário configurar o URL types, URL identifier e URL Schemes dentro do artigo info.plist. Veja na figura.

    Imagem 1.1 – Criando as URLs necessárias para iOS

    2 – Agora dentro da classe AppDelegate.cs eu preciso criar um método, ou melhor, sobre-escrever um método chamado OpenUrl para receber qualquer parâmetro enviado pelo link. Segue o método.

    Código 1.2 – Método iOS

    public override bool OpenUrl(UIApplication application, NSUrl url, NSDictionary options)
{
    if (url != null &&
        url.Query.ToLower().Contains("token="))
    {
        //check data
        var token = url.Query.Substring("token=".Length);
    }
    return true;
}

    Note que o parâmetro url é um parâmetro do método e com ele vem o valor recebido. No exemplo eu crie um link com o nome do aplicativo e o parâmetro token.

    <a href="webtracktogo://token=12345">webtracktogo://token=1234</a>

    Esse link funciona via email ou webiste sem problema algum e assim ele chama o aplicativo identificado com o mesmo nome webtracktogo.

    Agora vou falar como funciona no Android.

    Android

    1 – Para o Android é necessário primeiro colocar alguns parâmetros dentro do artigo AndroidManisfest.xml, veja o código.

    Código 2.1 – AndroidManifest.xml

    <application android:label="QAS StarTrack Go" android:icon="@mipmap/webtracktogoicon">
    <activity android:name="WebTrack" android:exported="true">
        <intent-filter>
            <action android:name="android.intent.action.VIEW" />
            <category android:name="android.intent.category.DEFAULT" />
            <data android:scheme="webtracktogo"/>
        </intent-filter>
    </activity>
</application>

    Dentro da tag <application> é necessário utilizar o <activity> e o android:name coloquei o nome do aplicativo, ou seja, o mesmo nome do projeto. Depois disso, utilizei a tag <intent-filter> com o <data android:scheme…> e é aqui que eu devo colocar o nome do link que vai ser chamado, nesse caso webtracktogo.

    Nome tem que a action e a category que são necessárias para compilar o aplicativo.

    Depois disso, é necessário acessar a classe MauiProgram.cs para ativar as activities importantes para o Android que é diferente do iOS dentro do MAUI.

    Vou precisar configurar o LifecycleEvents e para isso vou colocar o código todo aqui.

    Código 2.2 – if ANDROID

    public static MauiApp CreateMauiApp()
{
    var builder = MauiApp.CreateBuilder();
    builder
        .UseMauiApp<App>()
        .UseMauiCameraView()    
        .UseMauiCommunityToolkit()
        .ConfigureEffects(effects =>
            {
                //effects.Add<DoneKeyboardButtonEffect, DoneKeyboardButtonPlatformEffect>();
                effects.Add<LoseFocusOnScrollEffect, LoseFocusOnScrollPlatformEffect>();
                effects.Add<AutofillPasswordEffect, AutofillPasswordPlatformEffect>();
            })
        .ConfigureFonts(fonts =>
        {
            fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
            fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
        })
        .ConfigureLifecycleEvents(lifecycle =>
        {
#if ANDROID
            lifecycle.AddAndroid(android =>
            {
                android.OnCreate((activity, bundle) =>
                {
                    var action = activity.Intent?.Action;
                    var data = activity.Intent?.Data?.ToString();

                    if (action == Android.Content.Intent.ActionView && data is not null)
                    {
                        Task.Run(() => HandleAppLink(data));
                    }
                });
            });
#endif
        });;

    #if IOS
        //register done button for iOS
        EntryHandlerKeyboard.AddDone();
    #endif

#if DEBUG || QAS
    builder.Logging.AddDebug();
#endif

    return builder.Build();
}

    Tudo que eu preciso te passar está dentro do #if ANDROID que configura na criação do App uma task que pega os dados e chama o método HandleAppLink(data) passando os dados.

    Código 2.3 – Método que pega os dados e valores

    /// <summary>
/// Getting values from webtracktogo:// appLink
/// </summary>
/// <param name="url">webtracktogo://</param>
static void HandleAppLink(string url)
{
    if (Uri.TryCreate(url, UriKind.RelativeOrAbsolute, out var uri))
    {
        if (uri != null &&
            uri.Query.ToLower().Contains("token="))
        {
            //check data
            var token = uri.Query.Substring("token=".Length);
        }   
    }
    //App.Current?.SendOnAppLinkRequestReceived(uri);
}

    Depois disso você pode fazer o que quiser e o aplicativo Android será chamado quando o link for clicado dentro do device do cliente ou usuário.

    <a href="webtracktogo://token=12345">webtracktogo://token=1234</a>

    Essa configuração é pequena perto do que tinha que fazer com o deeplink. Espero que tenha gostado e qualquer coisa pode entrar em contato comigo pelo site https://mauriciojunior.net

  • Gestão de riscos em projetos: sua trava de segurança na montanha-russa da execução

    Gestão de riscos em projetos: sua trava de segurança na montanha-russa da execução

    Projetos são intensos. Cheios de movimento, expectativa, pressão e decisões em alta velocidade. Lembram muito uma montanha-russa: trajetos planejados, curvas emocionantes, acelerações inesperadas. Mas tem uma diferença importante. No parque de diversões, tudo foi testado, inspecionado e calculado para funcionar com segurança. Em projetos, se você não cuida da gestão de riscos, pode sim sair dos trilhos.

    Gerenciar riscos não é sobre paranoia nem excesso de controle. É sobre criar segurança, manter clareza e antecipar o que pode virar problema antes que vire caos. O PMBOK trata isso com método. Planejar, identificar, analisar, responder e monitorar riscos faz parte de qualquer projeto bem conduzido. É o que transforma susto em aprendizado, e incerteza em preparo.

    Tudo começa com uma escolha estratégica: como o time vai lidar com riscos? Com que frequência vamos revisar, quem será responsável por acompanhar, como essas informações vão ser registradas? É como definir antes da largada quais cintos serão usados e quem faz a inspeção. Mesmo sem volante, alguém precisa estar no controle do que pode dar errado.

    Depois vem a identificação. E aqui entra uma das boas práticas mais negligenciadas: envolver o time. Quanto mais gente observando com atenção, mais chances de mapear riscos reais e específicos. É importante ouvir especialistas, analisar projetos anteriores, cruzar dados e até fazer brainstorming. Só dá para enfrentar o que foi reconhecido.

    Com a lista em mãos, priorizar é essencial. Nem tudo tem o mesmo peso. A análise qualitativa ajuda a separar o que tem alta chance de acontecer do que é apenas ruído. Em casos críticos, vale usar análise quantitativa para entender impacto financeiro, atrasos potenciais ou riscos combinados. E aqui entra a segunda boa prática: manter a matriz de riscos viva. Revisitada, atualizada, usada de verdade no dia a dia. Não é documento de gaveta.

    A próxima etapa é decidir o que fazer com cada risco. Evitar, mitigar, transferir ou aceitar. Cada escolha exige clareza e ação. E para isso funcionar, a terceira boa prática faz diferença: estabelecer gatilhos claros para agir. Quando uma situação específica ocorre, o plano é ativado. Sem achismo, sem hesitação.

    Tudo isso só funciona se for monitorado. Riscos mudam. Novos aparecem. Outros desaparecem. Por isso, revisar, conversar, ajustar estratégias e registrar aprendizados é parte da rotina de quem leva a gestão de riscos a sério.

    No final, a montanha-russa do projeto pode até ter momentos de adrenalina, mas não vira pesadelo. Porque projeto bem-sucedido não é o que nunca enfrentou riscos. É o que se preparou para eles e soube navegar com firmeza mesmo nas curvas mais inesperadas. ♦

    LEIA TAMBÉM

  • Novidades em UX/UI para 2025: O futuro do design de experiências digitais

    Novidades em UX/UI para 2025: O futuro do design de experiências digitais

    O design de experiência do usuário (UX) e a interface do usuário (UI) estão em constante evolução, acompanhando não só o avanço das tecnologias, mas também as mudanças nas expectativas e comportamentos dos usuários.

    Novidades em UX/UI

    Em 2025, diversas tendências vêm se consolidando como pilares de inovação no design digital, trazendo soluções estéticas e funcionais que enriquecem a experiência dos usuários. A seguir, destacamos as principais tendências em UX/UI que você precisa conhecer para manter seus produtos atualizados e relevantes.

    1. Modo escuro: estética moderna com benefícios reais

    O modo escuro já deixou de ser uma simples opção estética para se tornar uma preferência de muitos usuários, principalmente por reduzir o cansaço visual em ambientes com pouca luz e melhorar a duração da bateria em dispositivos móveis com telas OLED. Em 2025, o modo escuro não é mais um diferencial — é uma expectativa. Designers estão se desafiando a criar experiências visualmente agradáveis tanto no modo claro quanto no escuro, mantendo contraste, legibilidade e identidade visual consistentes.

    📎 Exemplo: Material Design – Dark Theme Guidelines
    (Material Design explica como projetar para modo escuro, com exemplos visuais claros)

    2. Neumorfismo: a nova fronteira do realismo digital

    O Neumorfismo, junção de “novo” e “esquemorfismo”, é um estilo visual que busca um equilíbrio entre o realismo e o minimalismo. Ele utiliza sombras suaves, iluminação sutil e elementos que imitam superfícies físicas, criando uma sensação de profundidade e toque. Apesar de controverso devido a problemas de acessibilidade, o Neumorfismo evolui com ajustes que tornam as interfaces mais inclusivas, sem perder o apelo visual tátil e sofisticado.

    📎 Exemplo: Neumorphism.io – Gerador de Neumorfismo
    (Uma ferramenta que gera exemplos de botões e caixas no estilo neumorfista em tempo real)

    3. Microinterações avançadas: detalhes que encantam

    Microinterações são pequenas animações ou respostas visuais que acontecem como feedback a ações do usuário — como um botão que muda de cor ao ser clicado ou um som sutil ao enviar uma mensagem. Em 2025, essas interações estão se tornando mais sofisticadas e inteligentes, contribuindo para interfaces mais responsivas, intuitivas e agradáveis. Elas ajudam o usuário a entender o sistema, corrigir ações e se sentir mais conectado à interface.

    📎 Exemplo: UX Collective – Microinteractions: The Secret of Great UX
    (Artigo excelente explicando o impacto e exemplos práticos de microinterações)

    4. Tipografia em negrito: clareza com personalidade

    A tipografia em negrito continua ganhando espaço como uma maneira eficaz de destacar informações importantes, aumentar a legibilidade e transmitir personalidade. Combinada com hierarquias bem definidas e paletas de cores coesas, ela ajuda a guiar a atenção do usuário, especialmente em dispositivos móveis onde o espaço visual é limitado. Mais do que uma escolha estética, é uma decisão estratégica para melhorar a experiência de leitura.

    📎 Exemplo: FontInUse – Examples of Bold Typography in Modern UI
    (Arquivo de exemplos reais de marcas e produtos usando tipografia forte e ousada)

    5. Design 3D: profundidade e imersão

    O uso de elementos 3D em interfaces digitais está se tornando mais acessível e popular. Em 2025, vemos uma incorporação mais orgânica de gráficos tridimensionais que enriquecem a interface com profundidade, realismo e interatividade. Seja para visualização de produtos em e-commerce, experiências imersivas em jogos ou demonstrações interativas em apps educacionais, o 3D está abrindo novas portas para o engajamento do usuário.

    📎 Exemplo: Spline – Design 3D interativo para web
    (Ferramenta moderna para criar e incorporar gráficos 3D em interfaces digitais, com vários exemplos prontos)

    6. Gradientes suaves: transições visuais que encantam

    Gradientes deixaram de ser tendência passageira para se tornar uma linguagem visual forte. Em vez de cores vibrantes e contrastes intensos, 2025 é o ano dos gradientes suaves, que criam atmosferas agradáveis, modernas e fluidas. Eles são usados para guiar a navegação, estabelecer o clima emocional da interface e adicionar profundidade sem comprometer a simplicidade.

    📎 Exemplo: UIGradients – Biblioteca de Gradientes
    (Exemplos lindos de gradientes prontos para usar, mostrando transições suaves modernas)

    7. Ilustrações para estados vazios e de erro: comunicação com empatia

    Estados vazios (como telas sem conteúdo) e mensagens de erro são momentos delicados na jornada do usuário. Uma tendência crescente é utilizar ilustrações personalizadas e amigáveis nesses momentos, humanizando a interface e reduzindo o impacto negativo da experiência. Essa abordagem transforma potenciais frustrações em oportunidades de conexão emocional com o usuário.

    📎 Exemplo: Humaaans – Biblioteca gratuita de ilustrações personalizáveis
    (Use para criar ilustrações simpáticas para estados de erro, onboarding e telas vazias)

    O ano de 2025 ainda reserva muitas surpresas…

    As tendências em UX/UI para 2025 mostram um equilíbrio entre estética e funcionalidade, com foco em experiências mais humanas, acessíveis e envolventes. Designers que adotam essas práticas não apenas criam interfaces visualmente agradáveis, mas também constroem relacionamentos mais sólidos com os usuários. Ao acompanhar essas tendências, você garante que seus produtos digitais estejam alinhados com as melhores práticas do mercado — e com as expectativas de um público cada vez mais exigente.

  • Como receber vários parâmetros separados por ponto e vírgula?

    Como receber vários parâmetros separados por ponto e vírgula?

    Olá pessoal, meu nome Mauricio Junior e hoje eu vou te falar como receber vários parâmetros separados por vírgula ou ponto e vírgula e o select fazer a separação de forma inteligente usando o IN dentro do seleção sem fazer FOR ou usar cursor.

    Problema

    O problema que eu tenho é: o cliente vai mandar valores separados por ponto e vírgula, por exemplo: VALOR1; VALOR2; VALOR3; VALOR4; e eu preciso separados os dados para fazer a busca dentro do select.

    Solução

    Existe um comando dentro do SQL Server chamado STRING_SPLIT que serve para separar os dados recebidos pelo valor que você precisa e eu posso colocar o resultado dentro da seleção com IN. Veja o código 1.

    Código 1 – Usando o STRING_PLIT

    SELECT value FROM STRING_SPLIT(@parametros, ';')

    O código 1 mostra o comando específico e agora eu preciso colocar ele dentro do Select que irei usar, mas antes vou te mostrar um exemplo simples.

    Código 2 – Colocando o STRING_PLIT dentro do IN.

    Veja o código 2. Note que o value retornado do select equivale ao valor separado para forma o dado que pode ser usado no IN que eu preciso.

    SELECT 
    Campo1,
    Campo2,
    Campo3
FROM
    Tabela
WHERE
    Campo1 IN
    (
        SELECT value FROM STRING_SPLIT(@parametros, ';')
    )
ORDER BY Campo2;

    Simples assim, seleciono os campos (campo1, campo2 e campo3) da tabela onde o campo1 vai buscar os valores retornados do STRING_PLIT. Esse é o segredo! Isso pode ser usado dentro de um select normal e dentro de uma stored procedure.

    Código 3 – Executando com parâmetros

    No código 3, eu já mostro os parâmetros informados através de variável e como ela vai funcionar. 

    DECLARE @parametros NVARCHAR(MAX);

SET @parametros = 'VALOR1;VALOR2;VALOR3';

SELECT 
    Campo1,
    Campo2,
    Campo3
FROM
    Tabela
WHERE
    Campo1 IN
    (
        SELECT value FROM STRING_SPLIT(@parametros, ';')
    )
ORDER BY Campo2;

    Espero que tenha gostado e qualquer dúvida pode entrar em contato pelo site www.mauriciojunior.net

     

     

     

  • Segurança de Dados X Inteligência Artificial: como proteger suas informações

    Segurança de Dados X Inteligência Artificial: como proteger suas informações

    É nítida a melhora de produtividade quando adotamos ferramentas de Inteligência Artificial nas organizações. A automatização de tarefas repetitivas e manuais, a personalização de campanhas ou produtos em larga escala, além do ganho na agilidade em responder às demandas do mercado são apenas alguns dos motivos para implementar esta inovadora tecnologia em qualquer empresa. Entretanto, há que se manter alerta também para os riscos que a IA oferece ao se deparar com essa quantidade de dados.

    Segurança de Dados X Inteligência Artificial

    Os riscos associados à Inteligência Artificial (IA) abrangem uma variedade de aspectos técnicos, éticos, econômicos e regulatórios. Outro ponto importante a ressaltar é que informações sensíveis de empresas, como seus códigos-fonte, devem estar protegidos de qualquer violação de segurança.

    Em diversas situações, as empresas de IA armazenam os dados inseridos pelos usuários em suas aplicações para treinar e aprimorar seus modelos, o que implica que as informações fornecidas podem ser usadas para responder a perguntas de outros usuários.

    A coleta e análise de grandes volumes de dados podem violar leis de privacidade, como a LGPD (Lei Geral de Proteção de Dados) no Brasil. Na Europa, temos o GDPR (Regulamento Geral sobre a Proteção de Dados).

    Essa lei, mesmo tendo sido feita para cidadãos da União Europeia, vigora também para todo tipo de serviço que chega a um cidadão do bloco, mesmo que seja de uma loja online localizada em outro país, por exemplo.

    O novo whitepaper promovido pela SUSE, nos mostra a necessidade crítica de implantação segura de IA nas empresas, destacando os riscos de usar Modelos de Linguagem de Grande Escala (LLMs) públicos para dados sensíveis. São examinados os possíveis riscos do uso de aplicações baseadas em SaaS, particularmente no que diz respeito ao controle de dados e conformidade regulatória, e como uma plataforma flexível, segura e de nível empresarial permite que as organizações implantem aplicações de IA generativa com confiança.

    Mitigar os riscos da Inteligência Artificial se tornou fundamental. Investir em formas que garantam segurança cibernética, sem esquecer da conformidade regulatória, são imperativos para o bom uso da ferramenta.

    Recentemente, o Senado aprovou um projeto que regulamenta a Inteligência Artificial no Brasil. O documento, validado em dezembro do ano passado, segue agora para aprovação na Câmara.

    GenAI Seguro e Privado

    As empresas que adotam tecnologias de IA enfrentam diversos desafios de segurança, incluindo preocupações com a privacidade e proteção de dados do GenAI, além de vulnerabilidades na cadeia de suprimentos de IA. Para lidar com esses riscos, a adoção de plataformas de IA privadas tende a crescer.

    Essas plataformas podem capacitar as empresas a terem total controle sobre seus dados, protegendo suas operações contra ameaças crescentes, como compartilhamento não autorizado de dados, não conformidade regulatória e a proliferação do uso de “Shadow AI” (uso não autorizado de ferramentas de Inteligência Artificial dentro de uma organização).

    A boa notícia é que, da mesma forma que a IA acelerou a digitalização das empresas, já é possível buscar na comunidade de desenvolvedores plataformas projetadas para fornecer soluções de IA de maneira segura, escalável e privada, permitindo que organizações aproveitem o poder da ferramenta enquanto mantêm o controle total sobre seus dados.

    Com o avanço da tecnologia e a conscientização sobre os riscos, o futuro da IA nas empresas será mais seguro e confiável, beneficiando tanto a inovação quanto a proteção das informações sensíveis.