Forem: João Vitor

PHP as a stateless language

João Vitor — Thu, 13 Feb 2025 00:43:46 +0000

If you've worked with PHP or web development, you've probably heard of stateless. But what does it mean? And why is it so important?

To start, let’s ask: What is stateless?

Stateless means "without state." In other words, the server doesn’t keep track of what happened before. Each request is independent, as if it were the first one. In PHP, this means that when a script runs, it does what it needs to do, sends a response to the browser, and... that’s it! On the next request, it starts from scratch, remembering nothing.

This doesn’t mean it’s a bad thing. In fact, it has some advantages, and PHP has ways to work around it when we need to store information (like login details or shopping carts).

So, how does PHP handle stateless?

PHP is stateless by nature, but it has a few "tricks" up its sleeve to store information between requests. The main ones are:

Sessions: Store data on the server and use a cookie in the browser to identify the user.
Cookies: Store information directly in the user’s browser.
Database: For more permanent stuff, like user data or orders.

But are there really advantages to this?

Scalability:
- Since each request is independent, it’s easy to distribute the workload across multiple servers. This is great for applications that need to grow.
Simplicity:
- You don’t need to manage state all the time. Each request is handled in isolation, which makes life easier for developers.
Reliability:
- If one server goes down, another can take over without issues, since there’s no state to recover.
Easy Caching:
- Stateless requests are easier to cache, which improves performance.
Compatibility with RESTful APIs:
- REST APIs are stateless by nature, so PHP fits perfectly into this model.

Here’s where things get tricky: the disadvantages of stateless in PHP

Manual State Management:
- For things like login or shopping carts, you need to use sessions, cookies, or databases. This can add some extra work.
Communication Overhead:
- In each request, you might need to send extra information (like cookies), which can increase network traffic.
Not Ideal for Real-Time:
- If you need real-time functionality (like a chat), the stateless model might not be the best. WebSockets are better suited for these cases.

Some examples of how to use sessions in PHP

Using Sessions in PHP Sessions are super useful for storing information between requests.

<?php
// Start the session
session_start();

// Store the user’s name in the session
$_SESSION['user'] = 'John';

// Retrieve the name from the session
echo "Welcome, " . $_SESSION['user'];
?>

In this mini script above, the user’s name is stored in the session and can be retrieved on other pages.

Using Cookies in PHP Cookies are another way to store information, but in the user’s browser.

<?php
// Create a cookie that expires in 1 hour
setcookie('user', 'John', time() + 3600);

// Retrieve the cookie value
if (isset($_COOKIE['user'])) {
    echo "Welcome, " . $_COOKIE['user'];
} else {
    echo "Cookie not set.";
}
?>

Authentication with Sessions A classic example is a login system:

<?php
session_start();

// Simulate a login
if ($_POST['username'] === 'admin' && $_POST['password'] === '1234') {
    $_SESSION['logged_in'] = true;
    $_SESSION['username'] = 'admin';
    echo "Login successful!";
} else {
    echo "Invalid credentials.";
}

// Check if the user is logged in
if (isset($_SESSION['logged_in']) && $_SESSION['logged_in'] === true) {
    echo "Welcome, " . $_SESSION['username'];
}
?>

Shopping Cart with Sessions A shopping cart is a great example of something that needs state, after all, no one wants their cart to empty on every page refresh:

<?php
session_start();

// Add a product to the cart
if (isset($_POST['product'])) {
    $_SESSION['cart'][] = $_POST['product'];
}

// Display the cart
if (!empty($_SESSION['cart'])) {
    echo "Shopping Cart:";
    foreach ($_SESSION['cart'] as $product) {
        echo "<li>" . htmlspecialchars($product) . "</li>";
    }
} else {
    echo "Cart is empty.";
}
?>

Conclusion

PHP is stateless by default, which brings several advantages like scalability and simplicity. But when we need to store information (like login details or shopping carts), we just use sessions, cookies, or databases, and everything works out.

O PHP como uma linguagem stateless

João Vitor — Thu, 13 Feb 2025 00:38:29 +0000

Se você já mexeu com PHP ou desenvolvimento web, provavelmente já ouviu falar em stateless. Mas o que isso significa? E por que é tão importante?

Para começar, podemos perguntar: O que é stateless?

Stateless quer dizer "sem estado". Traduzindo: o servidor não guarda informações sobre o que aconteceu antes. Cada requisição é independente, como se fosse a primeira. No PHP, isso significa que, quando um script roda, ele faz o que precisa fazer, manda a resposta para o navegador e... acabou! Na próxima requisição, ele começa do zero, sem lembrar de nada.

Isso não significa que seja ruim. Na verdade, tem algumas vantagens, e com o PHP existe um jeito de contornar isso quando precisamos guardar informações (como login ou carrinho de compras).

Então, como o PHP lida com o stateless?

O PHP é stateless por natureza, mas ele tem algumas "gambiarras" na manga para guardar informações entre uma requisição e outra.
As principais são:

Sessões: Guardam dados no servidor e usam um cookie no navegador para identificar o usuário.
Cookies: Armazenam informações diretamente no navegador do usuário.
Banco de Dados: Para coisas mais permanentes, como dados de usuários ou pedidos.

Mas realmente tem vantagens nisso?

Escalabilidade:
- Como cada requisição é independente, é fácil distribuir o trabalho entre vários servidores. Isso é ótimo para aplicações que precisam crescer.
Simplicidade:
- Não precisa ficar gerenciando estado o tempo todo. Cada requisição é tratada de forma isolada, o que facilita a vida do desenvolvedor.
Confiabilidade:
- Se um servidor cair, outro pode assumir sem problemas, já que não há estado a ser recuperado.
Facilidade de Cache:
- Requisições stateless são mais fáceis de armazenar em cache, o que melhora o desempenho.
Compatibilidade com APIs RESTful:
- APIs REST são stateless por natureza, então o PHP se encaixa perfeitamente nesse modelo.

É aqui que o filho chora e mãe não vê, as desvantagens que vem junto do Stateless no PHP

Precisa Gerenciar Estado Manualmente:
- Para coisas como login ou carrinho de compras, você precisa usar sessões, cookies ou banco de dados. Isso pode dar um pouco mais de trabalho.
Overhead de Comunicação:
- Em cada requisição, você pode precisar enviar informações extras (como cookies), o que pode aumentar o tráfego de rede.
Não é Ideal para Tempo Real:
- Se você precisa de algo em tempo real (como um chat), o modelo stateless pode não ser o melhor. Usar WebSockets são mais indicados nesses casos.

Alguns exemplos de como utilizar sessão no PHP

Usando Sessões no PHP Sessões são super úteis para guardar informações entre requisições.

<?php
// Inicia a sessão
session_start();

// Guarda o nome do usuário na sessão
$_SESSION['usuario'] = 'João';

// Recupera o nome da sessão
echo "Bem-vindo, " . $_SESSION['usuario'];
?>

Nesse mini script acima, o nome do usuário é guardado na sessão e pode ser recuperado em outras páginas.

Usando Cookies no PHP Cookies são outra forma de guardar informações, mas no navegador do usuário.

<?php
// Cria um cookie que expira em 1 hora
setcookie('usuario', 'João', time() + 3600);

// Recupera o valor do cookie
if (isset($_COOKIE['usuario'])) {
    echo "Bem-vindo, " . $_COOKIE['usuario'];
} else {
    echo "Cookie não definido.";
}
?>

Autenticação com Sessões Um exemplo clássico é o sistema de login:

<?php
session_start();

// Simulação de login
if ($_POST['usuario'] === 'admin' && $_POST['senha'] === '1234') {
    $_SESSION['logado'] = true;
    $_SESSION['usuario'] = 'admin';
    echo "Login bem-sucedido!";
} else {
    echo "Credenciais inválidas.";
}

// Verifica se o usuário está logado
if (isset($_SESSION['logado']) && $_SESSION['logado'] === true) {
    echo "Bem-vindo, " . $_SESSION['usuario'];
}
?>

Carrinho de Compras com Sessão Um carrinho de compras é um ótimo exemplo de algo que precisa de estado, afinal, ninguém quer ter o carrinho esvaziado em cada atualização da página:

<?php
session_start();

// Adiciona um produto ao carrinho
if (isset($_POST['produto'])) {
    $_SESSION['carrinho'][] = $_POST['produto'];
}

// Mostra o carrinho
if (!empty($_SESSION['carrinho'])) {
    echo "Carrinho de Compras:";
    foreach ($_SESSION['carrinho'] as $produto) {
        echo "<li>" . htmlspecialchars($produto) . "</li>";
    }
} else {
    echo "Carrinho vazio.";
}
?>

Conclusão

O PHP é stateless por padrão, o que traz várias vantagens, como escalabilidade e simplicidade. Mas, quando precisamos guardar informações (como login ou carrinho de compras), é só utilizar as sessões, cookies ou banco de dados e tudo se resolve.

Explorando os Fundamentos dos Padrões de Projeto: Conceitos Básicos

João Vitor — Tue, 26 Mar 2024 02:42:33 +0000

Afinal, o que são os Padrões de Projetos

Padrões de Projeto, no desenvolvimento de software, são soluções típicas para problemas recorrentes que surgem durante o design e implementação de um software.

São soluções elegantes, prontas, pensadas, testadas e aprovadas para situações comuns, que surgem no cotidiano de um dev.

Esses padrões auxiliam os desenvolvedores na resolução de soluções complexas de maneira mais eficaz, fornecendo uma linguagem comum e um conjunto de práticas estabelecidas. Além disso, promovem a reutilização de código, facilitando a manutenção e a evolução contínua do software.

Por que esses padrões de projeto são tão importantes?

Soluções comprovadas: Os padrões representam soluções testadas e comprovadas para problemas comuns no desenvolvimento de software. Eles foram criados a partir da experiência de desenvolvedores ao longo do tempo e fornecem uma maneira confiável de resolver problemas recorrentes.

Reutilização do código: Ao aplicar os padrões de projeto, é possível utilizar o código mais de uma vez, criando componentes. Isso promove a reutilização de código e reduz a duplicação, levando a um desenvolvimento mais eficiente.

Complexidade Reduzida: Os padrões promovem o acoplamento flexível entre os componentes, facilitando a substituição ou a ampliação de partes do sistema sem afetar outras. Essa flexibilidade é fundamental para a adaptação às mudanças de requisitos.

Mas afinal, quais são esses padrões?

Existem vários tipos de padrões de projetos, categorizados em três principais grupos:

1. Padrões de Criação (Creational Patterns):
Esse padrão simplifica o processo de instanciação de objetos, tornando um sistema independente da forma como esses objetos são criados, compostos e representados.
Exemplos incluem o Singleton, Factory Method, Abstract Factory, Builder e Prototype.

2. Padrões Estruturais (Structural Patterns):
Já esse padrão se se preocupa em como as classes e objetos são compostos para formar estruturas maiores, facilitando a criação de sistemas mais flexíveis e reutilizáveis.
Exemplos incluem o Adapter, Bridge, Composite, Decorator, Facade e Proxy.

3. Padrões Comportamentais (Behavioral Patterns):
Por fim, o padrão comportamental se concentra na interação entre objetos, ajudando a definir como os objetos se comunicam entre si e como o fluxo de controle é gerenciado dentro do sistema.
Exemplos incluem o Strategy, Observer, Command, Iterator, State e Template Method.

Alguns pontos que devem ser considerados ao implementar os padrões de projetos ao seu código

Os padrões não são pedaços de código que você pode copiar e jogar no seu software, eles são um conceito, são como plantas pré-projetadas, que podem ser alteradas para se adequar ao seu código.

Quando estiver familiarizado com um padrão, descubra onde ele se encaixa no seu projeto. Seja criterioso na sua aplicação; o uso excessivo pode complicar ainda mais as coisas.

Alguns padrões são complexos e podem exigir um tempo considerável para entender e implementar corretamente. Então, pode ser mais eficiente escrever uma solução direta e simples.

Conclusão

Embora os padrões de projetos possam trazer benefícios em muitos casos, é importante avaliar cada situação individualmente e decidir se a aplicação de um padrão específico é apropriada e benéfica para o seu projeto.
O objetivo é corrigir problemas de forma rápida e eficaz e que os padrões de projeto são apenas uma maneira de fazer isso.

Este artigo apenas apresenta conceitos simples e uma breve introdução aos Padrões de Projeto.

Cada um desses padrões pode ser explorado com muito mais profundidade, com exemplos e variações mais complexas para atender a requisitos específicos.