<?xml version="1.0"?>
<feed xmlns="http://www.w3.org/2005/Atom">
    <title>Blog do Marcolin</title>
    <link href="https://www.marcosmarcolin.com.br/blog" />
    <link type="application/atom+xml" rel="self" href="https://www.marcosmarcolin.com.br/feed.xml" />
    <updated>2026-11-20T00:00:00+00:00</updated>
    <id>https://www.marcosmarcolin.com.br/feed.xml</id>
    <author>
        <name>Marcos Marcolin</name>
    </author>
                <entry>
            <id>https://www.marcosmarcolin.com.br/blog/php-falhas-seguranca-novembro-2026</id>
            <link type="text/html" rel="alternate" href="https://www.marcosmarcolin.com.br/blog/php-falhas-seguranca-novembro-2026" />
            <title>PHP corrige 7 falhas críticas: o que fazer com o 8.5.13 e o 8.4.28</title>
            <published>2026-11-20T00:00:00+00:00</published>
            <updated>2026-11-20T00:00:00+00:00</updated>
            <author>
                <name>Marcos Marcolin</name>
            </author>
            <summary type="html">As 17 falhas corrigidas no PHP 8.5.13, 8.4.28, 8.3.37 e 8.2.36, incluindo RCE no PHP-FPM e o phpAfterShell: quem está em risco e como se proteger.</summary>
            <content type="html">&lt;p&gt;Um mês depois do &lt;a href=&quot;/blog/php2shell-vulnerabilidade-critica-no-php&quot;&gt;PHP2Shell&lt;/a&gt;, o PHP soltou mais uma leva de correções de segurança. E ela é maior: &lt;strong&gt;17 vulnerabilidades, 7 delas críticas&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;No dia 19/11 saíram o &lt;strong&gt;PHP 8.5.13, 8.4.28, 8.3.37 e 8.2.36&lt;/strong&gt;, todas releases de segurança. No mesmo dia também saiu o &lt;a href=&quot;/blog/php-86&quot;&gt;PHP 8.6.0&lt;/a&gt;, que já vem com todas essas correções.&lt;/p&gt;

&lt;p&gt;Se você não tiver tempo pra ler o resto, leve só isso: &lt;strong&gt;atualize para 8.5.13, 8.4.28, 8.3.37 ou 8.2.36 (ou para o 8.6.0) e reinicie os workers.&lt;/strong&gt; E se você usa PHP-FPM com conexões persistentes ou a imagem Docker oficial, leia a parte do FPM com atenção.&lt;/p&gt;

&lt;h2&gt;Sumário&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;#o-que-saiu&quot;&gt;O que saiu em 19/11&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#falhas-criticas&quot;&gt;As falhas críticas&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#falhas-altas-e-medias&quot;&gt;As falhas altas e médias&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#relacao-com-o-php2shell&quot;&gt;O que tem a ver com o PHP2Shell?&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#como-saber-se-estou-vulneravel&quot;&gt;Como saber se estou vulnerável?&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#nao-consigo-atualizar-agora&quot;&gt;Não consigo atualizar agora, e aí?&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#versoes-sem-suporte&quot;&gt;E quem está em versão sem suporte?&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#conclusao&quot;&gt;Conclusão&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a id=&quot;o-que-saiu&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;O que saiu em 19/11&lt;/h2&gt;

&lt;p&gt;O PHP avisou um dia antes que a release afetaria todas as versões suportadas e que a gravidade máxima era &lt;strong&gt;crítica&lt;/strong&gt;, mas que os casos críticos exigem configuração fora do padrão ou setups incomuns. Isso é importante: diferente do PHP2Shell, que atingia praticamente qualquer PHP respondendo HTTP, a maioria das falhas de agora depende de alguma condição específica.&lt;/p&gt;

&lt;p&gt;Segundo os advisories publicados no GitHub do php-src, são &lt;strong&gt;7 críticas, 4 altas e 6 médias&lt;/strong&gt; (CVSS v4.0), além da atualização da biblioteca uriparser embutida no &lt;code&gt;ext/uri&lt;/code&gt;, que aparece no changelog com a CVE-2026-48841. Por isso algumas matérias falam em 18 falhas. Também há quem fale em 4 críticas, mas os advisories oficiais classificam 7.&lt;/p&gt;

&lt;p&gt;Até o momento em que escrevo, &lt;strong&gt;não há relato de exploração ativa&lt;/strong&gt; dessas falhas, e nenhuma delas está no catálogo KEV da CISA. Mesmo assim, já circulam relatos de provas de conceito públicas para algumas delas. E, depois do PHP2Shell, eu não contaria com isso por muito tempo.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;falhas-criticas&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;As falhas críticas&lt;/h2&gt;

&lt;p&gt;Todas as críticas receberam &lt;strong&gt;CVSS v4.0 9.2&lt;/strong&gt;.&lt;/p&gt;

&lt;h3&gt;CVE-2026-129289: request smuggling no PHP-FPM&lt;/h3&gt;

&lt;p&gt;Essa é a mais grave do pacote, e a que mais merece atenção de quem roda FPM.&lt;/p&gt;

&lt;p&gt;Quando a aplicação abre o &lt;code&gt;php://input&lt;/code&gt; mas não lê o corpo da requisição até o fim, o PHP deixa de descartar o que sobrou. Com um corpo multipart malformado, sobram bytes do atacante na conexão. Se o servidor web reaproveita a conexão com o FPM (o &lt;code&gt;FCGI_KEEP_CONN&lt;/code&gt;), o FPM interpreta esses bytes como &lt;strong&gt;uma nova requisição FastCGI&lt;/strong&gt;, com parâmetros forjados como &lt;code&gt;SCRIPT_FILENAME&lt;/code&gt;, &lt;code&gt;REMOTE_ADDR&lt;/code&gt; e &lt;code&gt;PHP_ADMIN_VALUE&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;A partir daí, se o atacante souber o caminho de algum script PHP que existe no servidor, basta ligar &lt;code&gt;allow_url_include&lt;/code&gt; e apontar o &lt;code&gt;auto_prepend_file&lt;/code&gt; para &lt;code&gt;php://input&lt;/code&gt; pra executar código PHP:&lt;/p&gt;

&lt;figure class=&quot;viz&quot; role=&quot;img&quot; aria-label=&quot;Fluxo da CVE-2026-129289, do corpo malformado até a execução de código no PHP-FPM&quot;&gt;
&lt;svg viewBox=&quot;0 0 480 384&quot; xmlns=&quot;http://www.w3.org/2000/svg&quot;&gt;
&lt;defs&gt;&lt;marker id=&quot;arr-fpm&quot; viewBox=&quot;0 0 10 10&quot; refX=&quot;9&quot; refY=&quot;5&quot; markerWidth=&quot;7&quot; markerHeight=&quot;7&quot; orient=&quot;auto&quot;&gt;&lt;path class=&quot;arrow&quot; d=&quot;M0,0 L10,5 L0,10 z&quot;/&gt;&lt;/marker&gt;&lt;/defs&gt;
&lt;rect class=&quot;box&quot; x=&quot;40&quot; y=&quot;10&quot; width=&quot;400&quot; height=&quot;40&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;240&quot; y=&quot;35&quot; text-anchor=&quot;middle&quot;&gt;Atacante envia um corpo multipart malformado&lt;/text&gt;
&lt;line class=&quot;line&quot; x1=&quot;240&quot; y1=&quot;50&quot; x2=&quot;240&quot; y2=&quot;70&quot; marker-end=&quot;url(#arr-fpm)&quot;/&gt;
&lt;rect class=&quot;box&quot; x=&quot;40&quot; y=&quot;72&quot; width=&quot;400&quot; height=&quot;40&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;240&quot; y=&quot;97&quot; text-anchor=&quot;middle&quot;&gt;A aplicação abre o php://input e não lê até o fim&lt;/text&gt;
&lt;line class=&quot;line&quot; x1=&quot;240&quot; y1=&quot;112&quot; x2=&quot;240&quot; y2=&quot;132&quot; marker-end=&quot;url(#arr-fpm)&quot;/&gt;
&lt;rect class=&quot;box&quot; x=&quot;40&quot; y=&quot;134&quot; width=&quot;400&quot; height=&quot;40&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;240&quot; y=&quot;159&quot; text-anchor=&quot;middle&quot;&gt;O resto do corpo fica na conexão reaproveitada&lt;/text&gt;
&lt;line class=&quot;line&quot; x1=&quot;240&quot; y1=&quot;174&quot; x2=&quot;240&quot; y2=&quot;194&quot; marker-end=&quot;url(#arr-fpm)&quot;/&gt;
&lt;rect class=&quot;box-bad&quot; x=&quot;40&quot; y=&quot;196&quot; width=&quot;400&quot; height=&quot;40&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;240&quot; y=&quot;221&quot; text-anchor=&quot;middle&quot;&gt;O FPM lê esses bytes como uma nova requisição FastCGI&lt;/text&gt;
&lt;line class=&quot;line&quot; x1=&quot;240&quot; y1=&quot;236&quot; x2=&quot;240&quot; y2=&quot;256&quot; marker-end=&quot;url(#arr-fpm)&quot;/&gt;
&lt;rect class=&quot;box-bad&quot; x=&quot;40&quot; y=&quot;258&quot; width=&quot;400&quot; height=&quot;40&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;240&quot; y=&quot;283&quot; text-anchor=&quot;middle&quot;&gt;PHP_ADMIN_VALUE forjado: allow_url_include e auto_prepend_file&lt;/text&gt;
&lt;line class=&quot;line&quot; x1=&quot;240&quot; y1=&quot;298&quot; x2=&quot;240&quot; y2=&quot;318&quot; marker-end=&quot;url(#arr-fpm)&quot;/&gt;
&lt;rect class=&quot;box-bad&quot; x=&quot;40&quot; y=&quot;320&quot; width=&quot;400&quot; height=&quot;40&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t-b&quot; x=&quot;240&quot; y=&quot;345&quot; text-anchor=&quot;middle&quot;&gt;O código do atacante é executado&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;240&quot; y=&quot;378&quot; text-anchor=&quot;middle&quot;&gt;Só acontece se o servidor web reaproveita a conexão com o FPM&lt;/text&gt;
&lt;/svg&gt;
&lt;figcaption&gt;CVE-2026-129289: uma requisição vira duas, e a segunda é do atacante.&lt;/figcaption&gt;
&lt;/figure&gt;

&lt;p&gt;É &lt;strong&gt;RCE sem autenticação, numa única requisição&lt;/strong&gt;, sem depender de corrupção de memória. E as configurações alteradas podem continuar valendo naquele worker.&lt;/p&gt;

&lt;p&gt;O lado bom: só afeta quem reaproveita conexões com o FPM, como &lt;code&gt;fastcgi_keep_conn on&lt;/code&gt; no Nginx, &lt;code&gt;enablereuse=on&lt;/code&gt; no Apache ou HAProxy com conexões persistentes. &lt;strong&gt;A configuração padrão do Nginx e do Apache não é afetada.&lt;/strong&gt; O código vulnerável existe desde o PHP 5.6. Detalhes no advisory &lt;a href=&quot;https://github.com/php/php-src/security/advisories/GHSA-qc49-hpvq-g2w6&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;GHSA-qc49-hpvq-g2w6&lt;/a&gt;.&lt;/p&gt;

&lt;h3&gt;CVE-2026-115560: mistura de serializers nas sessões&lt;/h3&gt;

&lt;p&gt;Essa já tinha sido anunciada em 23/10, logo depois do PHP2Shell, e agora ganhou correção. O &lt;em&gt;session upload progress&lt;/em&gt; grava dados de progresso com um serializer (&lt;code&gt;php_binary&lt;/code&gt; ou &lt;code&gt;php_serialize&lt;/code&gt;) e depois eles podem ser lidos com outro (&lt;code&gt;php&lt;/code&gt;). Um &lt;code&gt;|&lt;/code&gt; no valor enviado em &lt;code&gt;PHP_SESSION_UPLOAD_PROGRESS&lt;/code&gt;, que o PHP usa na chave da sessão, vira delimitador e o conteúdo chega ao &lt;code&gt;unserialize()&lt;/code&gt;. Resultado: injeção de objetos, que vira RCE se a aplicação tiver uma &lt;em&gt;gadget chain&lt;/em&gt; disponível. O advisory cita cadeias reproduzidas com Guzzle e Monolog.&lt;/p&gt;

&lt;p&gt;Exige que o upload progress esteja ligado e que o serializer mude em tempo de execução ou seja diferente entre aplicações, pools ou jobs CLI que compartilham o mesmo armazenamento de sessão.&lt;/p&gt;

&lt;p&gt;A correção traz uma &lt;strong&gt;mudança de comportamento&lt;/strong&gt;: o &lt;code&gt;session.upload_progress.enabled&lt;/code&gt; passa a vir &lt;strong&gt;desligado por padrão&lt;/strong&gt;, e mudar configurações de sessão em tempo de execução com ele ligado passa a ser rejeitado. Se você usa barra de progresso de upload, vai precisar ligar explicitamente. Advisory: &lt;a href=&quot;https://github.com/php/php-src/security/advisories/GHSA-658j-r8rw-q6mx&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;GHSA-658j-r8rw-q6mx&lt;/a&gt;.&lt;/p&gt;

&lt;h3&gt;CVE-2026-126714: o phpAfterShell&lt;/h3&gt;

&lt;p&gt;Essa foi encontrada pela depthfirst &lt;strong&gt;analisando justamente a correção do PHP2Shell&lt;/strong&gt;, e por isso ganhou o apelido de &lt;em&gt;phpAfterShell&lt;/em&gt;.&lt;/p&gt;

&lt;p&gt;O handler de sessão &lt;code&gt;files&lt;/code&gt;, o padrão do PHP, não truncava o arquivo antes de escrever. Uma escrita interrompida deixava o começo da sessão nova com o final da antiga, e essa mistura podia desserializar objetos do atacante. O advisory diz que a RCE depende de uma gadget chain, mas a depthfirst afirma ter montado a cadeia completa só com classes nativas do PHP, sem depender da aplicação. O caminho remoto também passa pelo upload progress, então a mesma mitigação da anterior vale aqui. Advisory: &lt;a href=&quot;https://github.com/php/php-src/security/advisories/GHSA-fm2m-fjf5-v3cp&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;GHSA-fm2m-fjf5-v3cp&lt;/a&gt;.&lt;/p&gt;

&lt;h3&gt;CVE-2026-129496: use after free no cache de timezone&lt;/h3&gt;

&lt;p&gt;Em builds NTS, um aviso na inicialização gravado num &lt;code&gt;error_log&lt;/code&gt; em arquivo, como um &lt;code&gt;date.timezone&lt;/code&gt; inválido, deixa um ponteiro solto. Se um worker novo emitir outro aviso logo no começo da requisição, como o de &lt;code&gt;max_input_vars&lt;/code&gt;, ele usa esse ponteiro. Dá pra derrubar workers remotamente, e a RCE foi demonstrada localmente, com endereços conhecidos e configuração adicional. Se o seu log de inicialização tem avisos, corrija de qualquer forma. Advisory: &lt;a href=&quot;https://github.com/php/php-src/security/advisories/GHSA-gr4f-wgx5-jpfv&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;GHSA-gr4f-wgx5-jpfv&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;As outras três críticas são consequências diretas do PHP2Shell, e falo delas &lt;a href=&quot;#relacao-com-o-php2shell&quot;&gt;mais abaixo&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;falhas-altas-e-medias&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;As falhas altas e médias&lt;/h2&gt;

&lt;h3&gt;CVE-2026-129291: escalada de privilégio no PHP-FPM&lt;/h3&gt;

&lt;p&gt;Nota &lt;strong&gt;8.8&lt;/strong&gt;, mas com um detalhe que pega muita gente: com o &lt;code&gt;catch_workers_output&lt;/code&gt; ligado, um código rodando como o usuário do pool consegue executar comandos como o &lt;strong&gt;processo master do FPM, que normalmente roda como root&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;O padrão do &lt;code&gt;catch_workers_output&lt;/code&gt; é &lt;code&gt;no&lt;/code&gt;, mas &lt;strong&gt;as imagens Docker oficiais do PHP ligam essa opção&lt;/strong&gt;, e a falha foi reproduzida nelas sem nenhuma modificação. É um ataque local, ou seja, o atacante já precisa executar código no pool. Mas, combinado com qualquer outra falha na aplicação, vira o caminho pra tomar o container inteiro. Advisory: &lt;a href=&quot;https://github.com/php/php-src/security/advisories/GHSA-jm4m-qfqx-967m&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;GHSA-jm4m-qfqx-967m&lt;/a&gt;.&lt;/p&gt;

&lt;h3&gt;CVE-2026-128064: &lt;code&gt;HTTPS://&lt;/code&gt; em maiúsculas vai sem criptografia&lt;/h3&gt;

&lt;p&gt;Essa é curiosa. Os stream wrappers de HTTP e FTP do PHP não reconheciam o esquema quando ele vinha com letras maiúsculas, então a requisição era enviada &lt;strong&gt;em texto puro&lt;/strong&gt;:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;// Antes da correção, isso saía sem TLS
$resposta = file_get_contents(&#039;HTTPS://api.exemplo.com/pedidos?token=segredo&#039;);
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Vale também para &lt;code&gt;FTPS://&lt;/code&gt; e para destinos de redirecionamento, o que significa que um servidor pode redirecionar sua requisição pra uma URL com esquema em maiúsculas e receber tudo sem criptografia. Tokens, senhas e o corpo da requisição ficam expostos pra quem estiver no caminho. Nota &lt;strong&gt;8.2&lt;/strong&gt;. Advisory: &lt;a href=&quot;https://github.com/php/php-src/security/advisories/GHSA-f6gg-rchx-xw8j&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;GHSA-f6gg-rchx-xw8j&lt;/a&gt;.&lt;/p&gt;

&lt;h3&gt;As demais&lt;/h3&gt;

&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
  &lt;th&gt;CVE&lt;/th&gt;
  &lt;th&gt;Componente&lt;/th&gt;
  &lt;th&gt;O que é&lt;/th&gt;
  &lt;th&gt;Nota&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
  &lt;td&gt;CVE-2026-127960&lt;/td&gt;
  &lt;td&gt;Wrapper HTTP&lt;/td&gt;
  &lt;td&gt;Cabeçalhos &quot;dobrados&quot; fazem um servidor malicioso travar a CPU (DoS)&lt;/td&gt;
  &lt;td&gt;8.7&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;CVE-2026-128090&lt;/td&gt;
  &lt;td&gt;Phar&lt;/td&gt;
  &lt;td&gt;Troca do algoritmo de assinatura ignora a chave OpenSSL&lt;/td&gt;
  &lt;td&gt;7.7&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;CVE-2026-129538&lt;/td&gt;
  &lt;td&gt;php-cgi&lt;/td&gt;
  &lt;td&gt;Leitura e escrita fora dos limites ao corrigir o &lt;code&gt;PATH_INFO&lt;/code&gt;&lt;/td&gt;
  &lt;td&gt;6.9&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;CVE-2026-15353&lt;/td&gt;
  &lt;td&gt;SOAP&lt;/td&gt;
  &lt;td&gt;Vazamento de 4 bytes do heap&lt;/td&gt;
  &lt;td&gt;6.3&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;CVE-2026-129506&lt;/td&gt;
  &lt;td&gt;SOAP&lt;/td&gt;
  &lt;td&gt;Use after free em entidades de DTD (DoS)&lt;/td&gt;
  &lt;td&gt;6.3&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;CVE-2026-129501&lt;/td&gt;
  &lt;td&gt;DOM&lt;/td&gt;
  &lt;td&gt;Double free no &lt;code&gt;saveXml()&lt;/code&gt; do &lt;code&gt;Dom\XMLDocument&lt;/code&gt; e do &lt;code&gt;Dom\HTMLDocument&lt;/code&gt; (8.4 e 8.5)&lt;/td&gt;
  &lt;td&gt;6.3&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;CVE-2026-129438&lt;/td&gt;
  &lt;td&gt;URI&lt;/td&gt;
  &lt;td&gt;Overflow ao serializar URIs de ~2 GiB (só 8.5)&lt;/td&gt;
  &lt;td&gt;6.3&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;CVE-2026-129292&lt;/td&gt;
  &lt;td&gt;PHP-FPM&lt;/td&gt;
  &lt;td&gt;XSS na página de status&lt;/td&gt;
  &lt;td&gt;5.3&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;

&lt;p&gt;A do php-cgi não afeta FPM nem mod_php. A do DOM afeta só a API nova (&lt;code&gt;Dom\XMLDocument&lt;/code&gt; e &lt;code&gt;Dom\HTMLDocument&lt;/code&gt;), não o &lt;code&gt;DOMDocument&lt;/code&gt; antigo.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;relacao-com-o-php2shell&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;O que tem a ver com o PHP2Shell?&lt;/h2&gt;

&lt;p&gt;Bastante. Das 7 críticas, &lt;strong&gt;quatro nasceram diretamente do caso de outubro&lt;/strong&gt;, e uma quinta foi anunciada junto com ele:&lt;/p&gt;

&lt;figure class=&quot;viz&quot; role=&quot;img&quot; aria-label=&quot;As cinco falhas críticas de novembro ligadas ao PHP2Shell&quot;&gt;
&lt;svg viewBox=&quot;0 0 480 310&quot; xmlns=&quot;http://www.w3.org/2000/svg&quot;&gt;
&lt;rect class=&quot;box-bad&quot; x=&quot;6&quot; y=&quot;125&quot; width=&quot;130&quot; height=&quot;60&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t-b&quot; x=&quot;71&quot; y=&quot;150&quot; text-anchor=&quot;middle&quot;&gt;PHP2Shell&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;71&quot; y=&quot;168&quot; text-anchor=&quot;middle&quot;&gt;outubro de 2026&lt;/text&gt;
&lt;path class=&quot;line&quot; d=&quot;M136,155 L160,155 L160,33 L190,33&quot;/&gt;
&lt;path class=&quot;line&quot; d=&quot;M160,95 L190,95&quot;/&gt;
&lt;path class=&quot;line&quot; d=&quot;M160,155 L190,155&quot;/&gt;
&lt;path class=&quot;line&quot; d=&quot;M160,215 L190,215&quot;/&gt;
&lt;path class=&quot;line&quot; d=&quot;M160,155 L160,277 L190,277&quot;/&gt;
&lt;rect class=&quot;box&quot; x=&quot;190&quot; y=&quot;10&quot; width=&quot;284&quot; height=&quot;46&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t-b&quot; x=&quot;202&quot; y=&quot;30&quot;&gt;CVE-2026-129481 (8.3 a 8.5)&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;202&quot; y=&quot;47&quot;&gt;Correção incompleta da CVE-2026-109619&lt;/text&gt;
&lt;rect class=&quot;box&quot; x=&quot;190&quot; y=&quot;72&quot; width=&quot;284&quot; height=&quot;46&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t-b&quot; x=&quot;202&quot; y=&quot;92&quot;&gt;CVE-2026-129182 (só 8.5)&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;202&quot; y=&quot;109&quot;&gt;Backtrace preenchido de novo após o shutdown&lt;/text&gt;
&lt;rect class=&quot;box&quot; x=&quot;190&quot; y=&quot;132&quot; width=&quot;284&quot; height=&quot;46&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t-b&quot; x=&quot;202&quot; y=&quot;152&quot;&gt;CVE-2026-129474 (só 8.5)&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;202&quot; y=&quot;169&quot;&gt;Alcançável pelo novo tratamento de OOM&lt;/text&gt;
&lt;rect class=&quot;box&quot; x=&quot;190&quot; y=&quot;192&quot; width=&quot;284&quot; height=&quot;46&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t-b&quot; x=&quot;202&quot; y=&quot;212&quot;&gt;CVE-2026-126714 (phpAfterShell)&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;202&quot; y=&quot;229&quot;&gt;Encontrada analisando o patch do PHP2Shell&lt;/text&gt;
&lt;rect class=&quot;box&quot; x=&quot;190&quot; y=&quot;254&quot; width=&quot;284&quot; height=&quot;46&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t-b&quot; x=&quot;202&quot; y=&quot;274&quot;&gt;CVE-2026-115560&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;202&quot; y=&quot;291&quot;&gt;Anunciada junto, mas é uma falha separada&lt;/text&gt;
&lt;/svg&gt;
&lt;figcaption&gt;Cinco das sete críticas de novembro têm ligação com o caso de outubro.&lt;/figcaption&gt;
&lt;/figure&gt;

&lt;p&gt;As três primeiras são falhas de memória (use after free) no shutdown e nos backtraces. As duas exclusivas do 8.5 dependem do &lt;code&gt;fatal_error_backtraces&lt;/code&gt;, que é o padrão no 8.5. A CVE-2026-129474 também exige &lt;code&gt;zend.exception_ignore_args=0&lt;/code&gt;, e o &lt;code&gt;php.ini-production&lt;/code&gt; já vem com o valor &lt;code&gt;1&lt;/code&gt;, o que bloqueia o ataque. Detalhes nos advisories &lt;a href=&quot;https://github.com/php/php-src/security/advisories/GHSA-g3vh-838c-65v7&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;GHSA-g3vh-838c-65v7&lt;/a&gt;, &lt;a href=&quot;https://github.com/php/php-src/security/advisories/GHSA-2fjv-p558-g82m&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;GHSA-2fjv-p558-g82m&lt;/a&gt; e &lt;a href=&quot;https://github.com/php/php-src/security/advisories/GHSA-8mjj-2r7p-4hg2&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;GHSA-8mjj-2r7p-4hg2&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Isso não é sinal de que a correção de outubro foi mal feita. É o que costuma acontecer depois de uma falha grande: todo mundo, pesquisadores e atacantes, vai olhar o mesmo código com lupa, muitas vezes com ajuda de IA. A correção do PHP2Shell mexeu em mais de 300 arquivos, e era de se esperar que aparecessem cantos ainda não cobertos.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;como-saber-se-estou-vulneravel&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Como saber se estou vulnerável?&lt;/h2&gt;

&lt;p&gt;Você está protegido se estiver em uma destas versões ou superior:&lt;/p&gt;

&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
  &lt;th&gt;Branch&lt;/th&gt;
  &lt;th&gt;Versão corrigida&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
  &lt;td&gt;8.6&lt;/td&gt;
  &lt;td&gt;8.6.0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;8.5&lt;/td&gt;
  &lt;td&gt;8.5.13&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;8.4&lt;/td&gt;
  &lt;td&gt;8.4.28&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;8.3&lt;/td&gt;
  &lt;td&gt;8.3.37&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;8.2&lt;/td&gt;
  &lt;td&gt;8.2.36&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;8.1 ou anterior&lt;/td&gt;
  &lt;td&gt;Sem correção do PHP&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;

&lt;p&gt;O mesmo teste do post do PHP2Shell, atualizado. Crie um arquivo temporário no servidor, acesse pelo navegador (assim ele roda na mesma SAPI do site) e &lt;strong&gt;apague logo depois&lt;/strong&gt;:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;&amp;lt;?php
$fixed = [&#039;8.6&#039; =&amp;gt; &#039;8.6.0&#039;, &#039;8.5&#039; =&amp;gt; &#039;8.5.13&#039;, &#039;8.4&#039; =&amp;gt; &#039;8.4.28&#039;, &#039;8.3&#039; =&amp;gt; &#039;8.3.37&#039;, &#039;8.2&#039; =&amp;gt; &#039;8.2.36&#039;];
$branch = PHP_MAJOR_VERSION . &#039;.&#039; . PHP_MINOR_VERSION;

echo &#039;Versão: &#039;, PHP_VERSION, &#039; | SAPI: &#039;, PHP_SAPI, PHP_EOL;

if (!isset($fixed[$branch])) {
    echo &#039;Branch sem suporte: não existe release oficial com a correção&#039;, PHP_EOL;
} elseif (version_compare(PHP_VERSION, $fixed[$branch], &#039;&amp;lt;&#039;)) {
    echo &quot;VULNERÁVEL: atualize para {$fixed[$branch]} ou superior&quot;, PHP_EOL;
} else {
    echo &#039;Versão com a correção&#039;, PHP_EOL;
}

// Configurações que aumentam a exposição até você atualizar
echo &#039;session.upload_progress.enabled: &#039;, ini_get(&#039;session.upload_progress.enabled&#039;) ?: &#039;0&#039;, PHP_EOL;
echo &#039;zend.exception_ignore_args: &#039;, ini_get(&#039;zend.exception_ignore_args&#039;) ?: &#039;0&#039;, PHP_EOL;
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Se você usa PHP-FPM, confira também o servidor web e o pool:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;# Nginx: conexões persistentes com o FPM (CVE-2026-129289)
grep -rn &quot;fastcgi_keep_conn&quot; /etc/nginx/

# Pool do FPM: catch_workers_output (CVE-2026-129291)
grep -rn &quot;catch_workers_output&quot; /usr/local/etc/php-fpm.d/ /etc/php/*/fpm/pool.d/ 2&amp;gt;/dev/null
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Os mesmos cuidados de outubro continuam valendo:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;pacotes de distro&lt;/strong&gt; (Debian, Ubuntu, RHEL) fazem backport sem mudar o número da versão. Consulte o aviso de segurança da sua distribuição. A Red Hat, por exemplo, classificou a CVE-2026-129289 como crítica;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;imagens Docker não se atualizam sozinhas&lt;/strong&gt;: faça &lt;code&gt;docker pull&lt;/code&gt;, rebuild e deploy;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;reinicie todos os workers&lt;/strong&gt; depois de atualizar ou de mudar qualquer configuração. Processo velho continua com o binário e o &lt;code&gt;php.ini&lt;/code&gt; antigos.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a id=&quot;nao-consigo-atualizar-agora&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Não consigo atualizar agora, e aí?&lt;/h2&gt;

&lt;p&gt;Estas mitigações cobrem as falhas mais graves. Elas &lt;strong&gt;reduzem&lt;/strong&gt; o risco, mas não substituem a atualização.&lt;/p&gt;

&lt;p&gt;No &lt;code&gt;php.ini&lt;/code&gt;:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-ini&quot;&gt;session.upload_progress.enabled = 0   ; CVE-2026-115560 e CVE-2026-126714
zend.exception_ignore_args = 1        ; CVE-2026-129474 (PHP 8.5)
fatal_error_backtraces = 0            ; CVE-2026-129182 (PHP 8.5)
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;No pool do FPM (&lt;code&gt;www.conf&lt;/code&gt; ou equivalente):&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-ini&quot;&gt;catch_workers_output = no                               ; CVE-2026-129291
php_admin_flag[session.upload_progress.enabled] = off   ; se o pool sobrescreve o php.ini
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Defina essas opções no &lt;code&gt;php.ini&lt;/code&gt; ou com &lt;code&gt;php_admin_*&lt;/code&gt;, nunca com &lt;code&gt;ini_set()&lt;/code&gt; na aplicação: nesse ponto a requisição já foi processada e é tarde demais.&lt;/p&gt;

&lt;p&gt;No servidor web, &lt;strong&gt;desligue o reaproveitamento de conexões com o FPM&lt;/strong&gt; (&lt;code&gt;fastcgi_keep_conn off&lt;/code&gt; no Nginx, sem &lt;code&gt;enablereuse=on&lt;/code&gt; no Apache). Isso fecha a CVE-2026-129289, a mais perigosa da lista. Pra CVE-2026-129496, corrija os avisos de inicialização ou mande o &lt;code&gt;error_log&lt;/code&gt; para o syslog.&lt;/p&gt;

&lt;p&gt;Depois de mudar qualquer uma dessas opções, &lt;strong&gt;reinicie todos os workers&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;versoes-sem-suporte&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;E quem está em versão sem suporte?&lt;/h2&gt;

&lt;p&gt;Em outubro, o próprio PHP publicou branches de backport pra 7.4, 8.0 e 8.1. &lt;strong&gt;Dessa vez, o PHP não publicou nada para as versões sem suporte.&lt;/strong&gt; E os advisories listam o PHP 8.1 como afetado sem correção em pelo menos duas falhas, a escalada de privilégio no FPM e o DoS no wrapper HTTP. Como várias falhas existem desde o PHP 4 ou 5, é bem provável que as versões antigas sejam afetadas por quase todas.&lt;/p&gt;

&lt;p&gt;A boa notícia vem, de novo, do &lt;strong&gt;Ondřej Surý&lt;/strong&gt;, que mantém os pacotes do &lt;code&gt;ppa:ondrej/php&lt;/code&gt; e do &lt;code&gt;deb.sury.org&lt;/code&gt;. Ele já portou as correções para o PHP 5.6 até o 8.1, como novas revisões dos pacotes. O número da versão não muda (o &lt;code&gt;php -v&lt;/code&gt; continua mostrando 8.1.34, por exemplo), então o que importa é a revisão do pacote:&lt;/p&gt;

&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
  &lt;th&gt;Versão&lt;/th&gt;
  &lt;th&gt;Revisão corrigida (ou superior)&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
  &lt;td&gt;8.1&lt;/td&gt;
  &lt;td&gt;&lt;code&gt;8.1.34-13&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;8.0&lt;/td&gt;
  &lt;td&gt;&lt;code&gt;1:8.0.30-30&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;7.4&lt;/td&gt;
  &lt;td&gt;&lt;code&gt;1:7.4.33-36&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;5.6 a 7.3&lt;/td&gt;
  &lt;td&gt;Também receberam revisões novas&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;

&lt;p&gt;Pra conferir:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;apt update &amp;amp;&amp;amp; apt upgrade
dpkg -l &#039;php8.1*&#039; | awk &#039;/^ii/ {print $2, $3}&#039;
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Se você usa algum espelho do PPA, os pacotes podem levar algumas horas pra chegar. O Ubuntu Pro também já publicou correções para os pacotes antigos, do PHP 5 ao 7.4, mas ainda não para todas as CVEs.&lt;/p&gt;

&lt;p&gt;Isso resolve o problema imediato, mas continua sendo paliativo: depende do trabalho voluntário de uma pessoa e não substitui estar numa versão suportada.&lt;/p&gt;

&lt;p&gt;E fica o lembrete: &lt;strong&gt;o PHP 8.2 sai de suporte em 31/12/2026&lt;/strong&gt;, daqui a pouco mais de um mês. A próxima leva de correções que afetar o 8.2 em 2027 já não vai ter release. Se você ainda está nele, a hora de planejar a migração é agora. E o &lt;a href=&quot;/blog/php-86&quot;&gt;PHP 8.6&lt;/a&gt; acabou de sair com bastante coisa boa.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;conclusao&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Conclusão&lt;/h2&gt;

&lt;p&gt;Essa release não teve o barulho do PHP2Shell, mas tem falhas tão sérias quanto, só que mais dependentes de configuração. A do FPM com conexões persistentes é a que eu olharia primeiro, seguida da escalada de privilégio nas imagens Docker oficiais.&lt;/p&gt;

&lt;p&gt;O ritmo também chama atenção: duas levas grandes de CVEs críticas em um mês. Isso tem muito a ver com o momento atual, em que a IA acelerou a descoberta de falhas antigas em todo o ecossistema, não só no PHP. O lado bom é que o PHP está respondendo dentro do ciclo normal de releases, com advisories detalhados e mitigações claras.&lt;/p&gt;

&lt;p&gt;A lição continua a mesma de outubro: &lt;strong&gt;atualize&lt;/strong&gt;, reinicie os workers e mantenha o ambiente num estado em que atualizar seja rotina, não emergência.&lt;/p&gt;

&lt;p&gt;Até a próxima e abraços! 🐘&lt;/p&gt;

&lt;p&gt;Referências:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.php.net/archive/2026.php&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;PHP.net: anúncios das releases 8.5.13, 8.4.28, 8.3.37, 8.2.36 e 8.6.0&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.php.net/ChangeLog-8.php&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;PHP.net: ChangeLog do PHP 8&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://github.com/php/php-src/security/advisories&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;GitHub: security advisories do php-src&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.php.net/supported-versions.php&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;PHP.net: versões suportadas&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.precursorsecurity.com/blog/phpaftershell-critical-php-rce-vulnerabilities&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;Precursor Security: phpAfterShell, critical PHP RCE vulnerabilities&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.techzine.eu/news/security/145948/php-security-updates-fix-18-vulnerabilities/&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;Techzine: PHP security updates fix 18 vulnerabilities&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.chainguard.dev/unchained/phps-november-security-release-what-it-is-and-what-to-update&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;Chainguard: PHP&#039;s November security release, what it is and what to update&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://access.redhat.com/hydra/rest/securitydata/cve/CVE-2026-129289.json&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;Red Hat: CVE-2026-129289&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content>
        </entry>
            <entry>
            <id>https://www.marcosmarcolin.com.br/blog/socket-io-v4-servidor-php</id>
            <link type="text/html" rel="alternate" href="https://www.marcosmarcolin.com.br/blog/socket-io-v4-servidor-php" />
            <title>Socket.IO v4 em PHP: servidor novo e benchmark com Node.js</title>
            <published>2026-11-16T00:00:00+00:00</published>
            <updated>2026-11-17T00:00:00+00:00</updated>
            <author>
                <name>Marcos Marcolin</name>
            </author>
            <summary type="html">Servidor Socket.IO v4 em PHP compatível com o socket.io-client v3 e v4: recursos, migração do phpsocket.io e benchmark contra o Node.js com JIT.</summary>
            <content type="html">&lt;p&gt;Desde 2021 eu uso o &lt;a href=&quot;https://github.com/walkor/phpsocket.io&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;phpsocket.io&lt;/a&gt; em produção. Ele entrou pra substituir um servidor legado em Node.js. Comecei como usuário, passei a contribuir com o projeto e, com o tempo, fui convidado a ser um dos mantenedores. É o pacote de Socket.IO mais usado no ecossistema PHP, mas ele tem uma limitação que pesa cada vez mais: só fala o protocolo antigo, então funciona apenas com o &lt;code&gt;socket.io-client&lt;/code&gt; 1.x e 2.x. Ele também continua no Workerman 4, porque o Workerman 5 exige PHP 8.1 e o pacote ainda atende quem está no PHP 7.4.&lt;/p&gt;

&lt;p&gt;Pra resolver isso, criei o &lt;a href=&quot;https://github.com/marcosmarcolin/socket.io-server&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;socket.io-server&lt;/a&gt;, um servidor Socket.IO v4 para PHP, feito sobre o &lt;a href=&quot;https://github.com/walkor/workerman&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;Workerman&lt;/a&gt;, um framework PHP pra servidores de rede assíncronos, que roda como um processo próprio, fora do PHP-FPM. Ele funciona com o &lt;code&gt;socket.io-client&lt;/code&gt; oficial v3 e v4, segue uma API parecida com a do phpsocket.io e, com OPcache e JIT ligados, chega perto do servidor oficial em Node.js gastando menos memória.&lt;/p&gt;

&lt;p&gt;O pacote está na versão 0.x e já pode ser usado. Se você precisa de Socket.IO v4 em PHP, ou quer sair do client 2.x, testa e me conta como foi: feedback, issues e pull requests são muito bem-vindos.&lt;/p&gt;

&lt;h2&gt;Sumário&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;#socketio-ou-websocket&quot;&gt;Socket.IO ou WebSocket: qual a diferença?&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#o-problema&quot;&gt;Por que o phpsocket.io não funciona com o socket.io-client v3 e v4&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#por-que-um-pacote-novo&quot;&gt;Por que um pacote novo&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#o-que-ele-faz&quot;&gt;O que ele faz&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#performance&quot;&gt;Performance contra o servidor oficial&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#soak-test&quot;&gt;Teste de carga contínua sem vazar memória&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#construindo-com-ia&quot;&gt;Como foi construir com IA&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#proximos-passos&quot;&gt;Estado atual e próximos passos&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#conclusao&quot;&gt;Conclusão&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#perguntas-frequentes&quot;&gt;Perguntas frequentes&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a id=&quot;socketio-ou-websocket&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Socket.IO ou WebSocket: qual a diferença?&lt;/h2&gt;

&lt;p&gt;O &lt;strong&gt;WebSocket&lt;/strong&gt; é um protocolo padrão da web que mantém uma conexão aberta entre client e servidor, pra que os dois mandem mensagens a qualquer momento, sem o client ter que ficar perguntando. Mas ele entrega só isso: mensagens soltas, de texto ou binárias. Reconexão, saber qual resposta é de qual pergunta, mandar pra um grupo de usuários, tudo fica por sua conta.&lt;/p&gt;

&lt;p&gt;O &lt;strong&gt;Socket.IO&lt;/strong&gt; nasceu em 2010 como uma biblioteca pra Node.js, e o servidor oficial continua sendo em Node. O protocolo dele é documentado, o que permite implementar servidores e clients em outras linguagens, como Java, Python e Rust.&lt;/p&gt;

&lt;p&gt;Ele não é uma alternativa ao WebSocket: usa o WebSocket como transporte e acrescenta, por cima, o que falta. São eventos com nome (&lt;code&gt;emit&lt;/code&gt; e &lt;code&gt;on&lt;/code&gt;), respostas por callback (os acknowledgements), rooms pra mandar mensagem pra grupos, reconexão automática e fallback pra HTTP long-polling (requisições HTTP que ficam abertas até ter algo pra responder) quando um proxy ou firewall bloqueia o WebSocket. Como ele tem protocolo próprio, um client Socket.IO não conversa com um servidor WebSocket puro, nem o contrário: o servidor também precisa falar Socket.IO, e na versão certa.&lt;/p&gt;

&lt;figure class=&quot;viz&quot; role=&quot;img&quot; aria-label=&quot;Como o Socket.IO funciona: o client A conecta por HTTP, sobe pra WebSocket, envia um evento, o servidor repassa pros clients da room e responde com um ack&quot;&gt;
&lt;svg viewBox=&quot;0 0 480 322&quot; xmlns=&quot;http://www.w3.org/2000/svg&quot;&gt;
&lt;defs&gt;&lt;marker id=&quot;arr-flow&quot; viewBox=&quot;0 0 10 10&quot; refX=&quot;9&quot; refY=&quot;5&quot; markerWidth=&quot;7&quot; markerHeight=&quot;7&quot; orient=&quot;auto-start-reverse&quot;&gt;&lt;path class=&quot;arrow&quot; d=&quot;M0,0 L10,5 L0,10 z&quot;/&gt;&lt;/marker&gt;&lt;/defs&gt;
&lt;rect class=&quot;box&quot; x=&quot;10&quot; y=&quot;10&quot; width=&quot;120&quot; height=&quot;34&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t-b&quot; x=&quot;70&quot; y=&quot;32&quot; text-anchor=&quot;middle&quot;&gt;Client A&lt;/text&gt;
&lt;line class=&quot;grid&quot; style=&quot;stroke-dasharray:4 3&quot; x1=&quot;70&quot; y1=&quot;44&quot; x2=&quot;70&quot; y2=&quot;288&quot;/&gt;
&lt;rect class=&quot;box&quot; x=&quot;180&quot; y=&quot;10&quot; width=&quot;120&quot; height=&quot;34&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t-b&quot; x=&quot;240&quot; y=&quot;32&quot; text-anchor=&quot;middle&quot;&gt;Servidor&lt;/text&gt;
&lt;line class=&quot;grid&quot; style=&quot;stroke-dasharray:4 3&quot; x1=&quot;240&quot; y1=&quot;44&quot; x2=&quot;240&quot; y2=&quot;288&quot;/&gt;
&lt;rect class=&quot;box&quot; x=&quot;350&quot; y=&quot;10&quot; width=&quot;120&quot; height=&quot;34&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t-b&quot; x=&quot;410&quot; y=&quot;32&quot; text-anchor=&quot;middle&quot;&gt;Client B&lt;/text&gt;
&lt;line class=&quot;grid&quot; style=&quot;stroke-dasharray:4 3&quot; x1=&quot;410&quot; y1=&quot;44&quot; x2=&quot;410&quot; y2=&quot;288&quot;/&gt;
&lt;line class=&quot;line&quot; x1=&quot;74&quot; y1=&quot;86&quot; x2=&quot;236&quot; y2=&quot;86&quot; marker-end=&quot;url(#arr-flow)&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;155&quot; y=&quot;78&quot; text-anchor=&quot;middle&quot;&gt;1. handshake via HTTP&lt;/text&gt;
&lt;line class=&quot;line&quot; x1=&quot;74&quot; y1=&quot;130&quot; x2=&quot;236&quot; y2=&quot;130&quot; marker-start=&quot;url(#arr-flow)&quot; marker-end=&quot;url(#arr-flow)&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;155&quot; y=&quot;122&quot; text-anchor=&quot;middle&quot;&gt;2. upgrade pra WebSocket&lt;/text&gt;
&lt;line class=&quot;line&quot; x1=&quot;74&quot; y1=&quot;174&quot; x2=&quot;236&quot; y2=&quot;174&quot; marker-end=&quot;url(#arr-flow)&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;155&quot; y=&quot;166&quot; text-anchor=&quot;middle&quot;&gt;3. emit(&#039;chat&#039;, &#039;oi&#039;)&lt;/text&gt;
&lt;line class=&quot;line&quot; x1=&quot;244&quot; y1=&quot;218&quot; x2=&quot;406&quot; y2=&quot;218&quot; marker-end=&quot;url(#arr-flow)&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;325&quot; y=&quot;210&quot; text-anchor=&quot;middle&quot;&gt;4. repassa pra room lobby&lt;/text&gt;
&lt;line class=&quot;line&quot; x1=&quot;236&quot; y1=&quot;262&quot; x2=&quot;74&quot; y2=&quot;262&quot; marker-end=&quot;url(#arr-flow)&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;155&quot; y=&quot;254&quot; text-anchor=&quot;middle&quot;&gt;5. ack(&#039;entregue&#039;)&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;240&quot; y=&quot;310&quot; text-anchor=&quot;middle&quot;&gt;Se a conexão cair, o client reconecta sozinho e recebe o que perdeu.&lt;/text&gt;
&lt;/svg&gt;
&lt;figcaption&gt;Como o Socket.IO funciona: o client B já está na room lobby, e o client A manda uma mensagem pra ela.&lt;/figcaption&gt;
&lt;/figure&gt;

&lt;p&gt;&lt;a id=&quot;o-problema&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Por que o phpsocket.io não funciona com o socket.io-client v3 e v4&lt;/h2&gt;

&lt;p&gt;O Socket.IO tem duas camadas. Por baixo está o &lt;strong&gt;Engine.IO&lt;/strong&gt;, que cuida da conexão: abre por HTTP long-polling, sobe pra WebSocket quando dá e mantém o heartbeat. Por cima está o &lt;strong&gt;Socket.IO&lt;/strong&gt;, com eventos, namespaces, rooms e acknowledgements.&lt;/p&gt;

&lt;figure class=&quot;viz&quot; role=&quot;img&quot; aria-label=&quot;Camadas do Socket.IO no client e no servidor: aplicação, Socket.IO, Engine.IO e transporte, com client e servidor falando a mesma versão de cada protocolo&quot;&gt;
&lt;svg viewBox=&quot;0 0 480 284&quot; xmlns=&quot;http://www.w3.org/2000/svg&quot;&gt;
&lt;defs&gt;&lt;marker id=&quot;arr-layers&quot; viewBox=&quot;0 0 10 10&quot; refX=&quot;9&quot; refY=&quot;5&quot; markerWidth=&quot;7&quot; markerHeight=&quot;7&quot; orient=&quot;auto-start-reverse&quot;&gt;&lt;path class=&quot;arrow&quot; d=&quot;M0,0 L10,5 L0,10 z&quot;/&gt;&lt;/marker&gt;&lt;/defs&gt;
&lt;text class=&quot;t-b&quot; x=&quot;91&quot; y=&quot;24&quot; text-anchor=&quot;middle&quot;&gt;Navegador&lt;/text&gt;
&lt;text class=&quot;t-b&quot; x=&quot;351&quot; y=&quot;24&quot; text-anchor=&quot;middle&quot;&gt;Servidor PHP&lt;/text&gt;
&lt;rect class=&quot;box&quot; x=&quot;6&quot; y=&quot;40&quot; width=&quot;170&quot; height=&quot;48&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;91&quot; y=&quot;69&quot; text-anchor=&quot;middle&quot;&gt;Seu código JavaScript&lt;/text&gt;
&lt;rect class=&quot;box&quot; x=&quot;266&quot; y=&quot;40&quot; width=&quot;170&quot; height=&quot;48&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;351&quot; y=&quot;69&quot; text-anchor=&quot;middle&quot;&gt;Seu código PHP&lt;/text&gt;
&lt;rect class=&quot;box&quot; x=&quot;6&quot; y=&quot;102&quot; width=&quot;170&quot; height=&quot;48&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;91&quot; y=&quot;122&quot; text-anchor=&quot;middle&quot;&gt;Socket.IO&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;91&quot; y=&quot;139&quot; text-anchor=&quot;middle&quot;&gt;socket.io-client&lt;/text&gt;
&lt;rect class=&quot;box&quot; x=&quot;266&quot; y=&quot;102&quot; width=&quot;170&quot; height=&quot;48&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;351&quot; y=&quot;122&quot; text-anchor=&quot;middle&quot;&gt;Socket.IO&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;351&quot; y=&quot;139&quot; text-anchor=&quot;middle&quot;&gt;eventos, rooms, acks&lt;/text&gt;
&lt;line class=&quot;crit-line&quot; style=&quot;stroke:var(--viz-muted)&quot; x1=&quot;176&quot; y1=&quot;126&quot; x2=&quot;266&quot; y2=&quot;126&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;221&quot; y=&quot;120&quot; text-anchor=&quot;middle&quot;&gt;protocolo v5&lt;/text&gt;
&lt;rect class=&quot;box&quot; x=&quot;6&quot; y=&quot;164&quot; width=&quot;170&quot; height=&quot;48&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;91&quot; y=&quot;184&quot; text-anchor=&quot;middle&quot;&gt;Engine.IO&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;91&quot; y=&quot;201&quot; text-anchor=&quot;middle&quot;&gt;dentro do client&lt;/text&gt;
&lt;rect class=&quot;box&quot; x=&quot;266&quot; y=&quot;164&quot; width=&quot;170&quot; height=&quot;48&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;351&quot; y=&quot;184&quot; text-anchor=&quot;middle&quot;&gt;Engine.IO&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;351&quot; y=&quot;201&quot; text-anchor=&quot;middle&quot;&gt;handshake, heartbeat, upgrade&lt;/text&gt;
&lt;line class=&quot;crit-line&quot; style=&quot;stroke:var(--viz-muted)&quot; x1=&quot;176&quot; y1=&quot;188&quot; x2=&quot;266&quot; y2=&quot;188&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;221&quot; y=&quot;182&quot; text-anchor=&quot;middle&quot;&gt;protocolo v4&lt;/text&gt;
&lt;rect class=&quot;box&quot; x=&quot;6&quot; y=&quot;226&quot; width=&quot;170&quot; height=&quot;48&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;91&quot; y=&quot;246&quot; text-anchor=&quot;middle&quot;&gt;Transporte&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;91&quot; y=&quot;263&quot; text-anchor=&quot;middle&quot;&gt;WebSocket ou HTTP&lt;/text&gt;
&lt;rect class=&quot;box&quot; x=&quot;266&quot; y=&quot;226&quot; width=&quot;170&quot; height=&quot;48&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;351&quot; y=&quot;246&quot; text-anchor=&quot;middle&quot;&gt;Workerman&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;351&quot; y=&quot;263&quot; text-anchor=&quot;middle&quot;&gt;TCP, HTTP e WebSocket&lt;/text&gt;
&lt;line class=&quot;line&quot; x1=&quot;180&quot; y1=&quot;250&quot; x2=&quot;262&quot; y2=&quot;250&quot; marker-start=&quot;url(#arr-layers)&quot; marker-end=&quot;url(#arr-layers)&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;221&quot; y=&quot;242&quot; text-anchor=&quot;middle&quot;&gt;rede&lt;/text&gt;
&lt;path class=&quot;line&quot; d=&quot;M438,100 H442 V214 H438&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;446&quot; y=&quot;157&quot; text-anchor=&quot;middle&quot; transform=&quot;rotate(90 446 157)&quot;&gt;socket.io-server&lt;/text&gt;
&lt;/svg&gt;
&lt;figcaption&gt;As camadas do Socket.IO. Client e servidor precisam falar a mesma versão de cada protocolo.&lt;/figcaption&gt;
&lt;/figure&gt;

&lt;p&gt;Na versão 3.0 do Socket.IO, lançada em 2020, as duas camadas mudaram de protocolo: o Engine.IO foi pra v4 e o Socket.IO pra v5. E a mudança é incompatível nos dois sentidos. Por padrão, um client 2.x não conecta num servidor v4 (o servidor oficial em Node tem a opção &lt;code&gt;allowEIO3&lt;/code&gt; pra aceitar os clients antigos durante uma migração), e um client v3 ou v4 não conecta num servidor antigo.&lt;/p&gt;

&lt;p&gt;O phpsocket.io implementa o protocolo antigo (Engine.IO v3). Na prática, quem usa PHP no servidor fica preso à linha 2.x do client JavaScript, que parou de receber recursos novos em 2020 (a última versão, a 2.5.0, é de 2022), sem o que veio depois, como a recuperação de estado da conexão.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;por-que-um-pacote-novo&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Por que um pacote novo&lt;/h2&gt;

&lt;p&gt;Hoje não existe servidor PHP pro Socket.IO v4 na &lt;a href=&quot;https://socket.io/docs/v4/&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;lista oficial de implementações&lt;/a&gt; do site. O outro pacote conhecido, o &lt;a href=&quot;https://github.com/hyperf/socketio-server&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;hyperf/socketio-server&lt;/a&gt;, implementa só o transporte WebSocket e documenta o client 2.x.&lt;/p&gt;

&lt;p&gt;A primeira ideia seria atualizar o próprio phpsocket.io. O problema é a incompatibilidade: trocar o protocolo quebraria todo mundo que usa o pacote hoje, porque os clients antigos deixariam de conectar. Migrar exige trocar client e servidor juntos, e isso tem que ser decisão de cada projeto, não um &lt;code&gt;composer update&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Tem também a versão do PHP. O phpsocket.io roda no Workerman 4 e aceita PHP 7.4, e quem usa ele hoje pode estar em versões antigas. O Workerman 5, a versão atual, exige PHP 8.1, então levar o phpsocket.io pra ele obrigaria todo mundo a atualizar o PHP junto. Num pacote novo, dava pra partir de uma base atual sem quebrar ninguém: PHP 8.1 ou superior, Workerman 5, tipos em tudo e PHPStan no nível máximo. O phpsocket.io segue atendendo os clients 1.x e 2.x, e o socket.io-server os v3 e v4.&lt;/p&gt;

&lt;p&gt;Pra facilitar a migração, a API do servidor segue o formato da do phpsocket.io, e o repositório tem um &lt;a href=&quot;https://github.com/marcosmarcolin/socket.io-server/blob/main/docs/migrating-from-phpsocket.io.md&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;guia de migração&lt;/a&gt; com o que muda no código e no client.&lt;/p&gt;

&lt;p&gt;O &lt;a href=&quot;https://github.com/walkor/phpsocket.io#readme&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;README do phpsocket.io&lt;/a&gt; já indica o socket.io-server pra quem precisa dos clients v3 e v4.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;o-que-ele-faz&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;O que ele faz&lt;/h2&gt;

&lt;p&gt;Um servidor completo cabe em poucas linhas:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;&amp;lt;?php

use Marcolin\SocketIO\Socket;
use Marcolin\SocketIO\SocketIO;
use Workerman\Worker;

require __DIR__ . &#039;/vendor/autoload.php&#039;;

$io = new SocketIO(3000, [&#039;cors&#039; =&amp;gt; [&#039;origin&#039; =&amp;gt; [&#039;https://example.com&#039;]]]);

$io-&amp;gt;on(&#039;connection&#039;, function (Socket $socket) use ($io): void {
    $socket-&amp;gt;join(&#039;lobby&#039;);
    $socket-&amp;gt;emit(&#039;hello&#039;, &#039;world&#039;);

    $socket-&amp;gt;on(&#039;chat&#039;, function (string $message, ?Closure $ack = null) use ($io): void {
        $io-&amp;gt;to(&#039;lobby&#039;)-&amp;gt;emit(&#039;chat&#039;, $message);
        if ($ack !== null) {
            $ack(&#039;delivered&#039;);
        }
    });
});

Worker::runAll();
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;E no client, o &lt;code&gt;socket.io-client&lt;/code&gt; oficial:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-js&quot;&gt;import { io } from &quot;socket.io-client&quot;;

const socket = io(&quot;http://localhost:3000&quot;);

socket.on(&quot;hello&quot;, (word) =&amp;gt; console.log(word));
socket.emit(&quot;chat&quot;, &quot;oi&quot;, (status) =&amp;gt; console.log(status)); // &quot;delivered&quot;
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;O que já está implementado:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Transportes:&lt;/strong&gt; HTTP long-polling e WebSocket na mesma porta, com o upgrade de um pro outro (WebTransport ainda não);&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Recursos do protocolo:&lt;/strong&gt; namespaces (canais separados no mesmo servidor, como &lt;code&gt;/chat&lt;/code&gt; e &lt;code&gt;/admin&lt;/code&gt;), middlewares, rooms, acknowledgements (inclusive em broadcast, com timeout), dados binários e listeners catch-all (que recebem qualquer evento);&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Recuperação de estado da conexão:&lt;/strong&gt; um client que perdeu a conexão volta com o mesmo socket, as mesmas rooms e os eventos que perdeu;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Vários processos e máquinas:&lt;/strong&gt; um evento enviado num processo chega aos clients conectados nos outros, via &lt;a href=&quot;https://github.com/walkor/channel&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;workerman/channel&lt;/a&gt; (um servidor de mensagens do próprio Workerman), Redis pub/sub ou Redis Streams;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;O resto:&lt;/strong&gt; CORS com cookies, TLS, compressão, log de debug e o Admin UI oficial (um painel web pra ver sockets, rooms e eventos ao vivo).&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Onde ele faz mais sentido: quando o time e a aplicação são PHP. Com o &lt;code&gt;Emitter&lt;/code&gt;, uma requisição comum no PHP-FPM manda eventos pros clients conectados, via Redis, sem precisar manter um serviço em Node.js só pra isso. Se a aplicação já é Node, o servidor oficial continua sendo a escolha natural.&lt;/p&gt;

&lt;p&gt;Pra saber se o servidor fala o protocolo do jeito certo, ele roda as suítes de conformidade oficiais do &lt;a href=&quot;https://github.com/socketio/socket.io/tree/main/docs/engine.io-protocol/v4-test-suite&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;Engine.IO&lt;/a&gt; (25 de 25 testes) e do &lt;a href=&quot;https://github.com/socketio/socket.io/tree/main/docs/socket.io-protocol/v5-test-suite&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;Socket.IO&lt;/a&gt; (32 de 32) em todo pull request, além de testes de integração com o client oficial, do PHP 8.1 ao 8.5.&lt;/p&gt;

&lt;h3&gt;O que dá pra construir&lt;/h3&gt;

&lt;p&gt;Os exemplos do repositório mostram como o pacote funciona, não o limite do que dá pra fazer com ele. Alguns deles:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Chat e mensagens privadas, com indicador de digitação e mensagens que chegam pra quem caiu e voltou (&lt;a href=&quot;https://github.com/marcosmarcolin/socket.io-server/tree/main/examples/chat&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;chat&lt;/a&gt;, &lt;a href=&quot;https://github.com/marcosmarcolin/socket.io-server/tree/main/examples/private-messaging&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;private-messaging&lt;/a&gt;);&lt;/li&gt;
&lt;li&gt;Notificações disparadas pela própria aplicação PHP (&lt;a href=&quot;https://github.com/marcosmarcolin/socket.io-server/tree/main/examples/emitter&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;emitter&lt;/a&gt;);&lt;/li&gt;
&lt;li&gt;Dashboards ao vivo, com o servidor empurrando números novos pra quem está olhando cada painel (&lt;a href=&quot;https://github.com/marcosmarcolin/socket.io-server/tree/main/examples/dashboard&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;dashboard&lt;/a&gt;);&lt;/li&gt;
&lt;li&gt;Jogos multiplayer: um Pong com fila de partidas e uma arena espacial com bots, com o loop do jogo rodando no servidor a 30 quadros por segundo (&lt;a href=&quot;https://github.com/marcosmarcolin/socket.io-server/tree/main/examples/pong&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;pong&lt;/a&gt;, &lt;a href=&quot;https://github.com/marcosmarcolin/socket.io-server/tree/main/examples/arena&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;arena&lt;/a&gt;).&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;São 14 exemplos ao todo, e cada um roda com um comando. Fora deles, o pacote serve pra qualquer coisa que precise de atualização em tempo real, como acompanhamento de pedidos e entregas, leilões, filas de atendimento, edição colaborativa e alertas de monitoramento.&lt;/p&gt;

&lt;h3&gt;Em produção&lt;/h3&gt;

&lt;p&gt;O servidor é um processo PHP de longa duração, então em produção ele precisa ficar sempre de pé e voltar sozinho se cair. Pra isso eu uso o &lt;a href=&quot;http://supervisord.org/&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;Supervisor&lt;/a&gt;, rodando o servidor em primeiro plano (&lt;code&gt;start&lt;/code&gt;, sem o &lt;code&gt;-d&lt;/code&gt;) e deixando o controle com ele:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-ini&quot;&gt;[program:socketio]
command=php -d memory_limit=512M /var/www/app/server.php start
directory=/var/www/app
user=www-data
autostart=true
autorestart=true
stopsignal=INT
stopasgroup=true
killasgroup=true
redirect_stderr=true
stdout_logfile=/var/log/socketio.log
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Com isso, &lt;code&gt;supervisorctl start socketio&lt;/code&gt;, &lt;code&gt;stop&lt;/code&gt;, &lt;code&gt;restart&lt;/code&gt; e &lt;code&gt;status&lt;/code&gt; controlam o processo, ele sobe junto com a máquina e é reiniciado se cair. Dois cuidados: o limite de arquivos abertos precisa ser maior que o número de conexões (no Supervisor, &lt;code&gt;minfds&lt;/code&gt; na seção &lt;code&gt;[supervisord]&lt;/code&gt;), e as configurações de OPcache e JIT da seção de performance valem aqui também.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;performance&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Performance contra o servidor oficial&lt;/h2&gt;

&lt;p&gt;Rodei o mesmo teste de carga no socket.io-server e no servidor oficial (&lt;code&gt;socket.io&lt;/code&gt; 4.8.4 no Node.js 24): um processo cada, mesmos handlers e mesma máquina (um MacBook Pro M4 Pro, tudo em Docker), com o &lt;code&gt;socket.io-client&lt;/code&gt; oficial via WebSocket e a extensão &lt;code&gt;event&lt;/code&gt; no PHP, que dá ao Workerman um event loop capaz de milhares de conexões (sem ela, ele usa o &lt;code&gt;select()&lt;/code&gt;, limitado a cerca de mil). Cada número é a mediana de três execuções, todas na mesma sessão.&lt;/p&gt;

&lt;p&gt;É um benchmark simples, com margem de erro: os números variam até 10% entre sessões, e até 15% dentro da mesma sessão com mil clientes. Servidor e clients rodam juntos numa única máquina, então os números servem pra comparar os servidores entre si, não como a capacidade de um servidor em produção. Medir um sistema em produção é difícil: rede, hardware, tamanho das mensagens e o código da própria aplicação mudam o resultado. Estes testes são uma estimativa, não uma promessa.&lt;/p&gt;

&lt;p&gt;Cada medição tem três partes:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Memória:&lt;/strong&gt; o RSS total do processo com todos os clients conectados;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Acknowledgements:&lt;/strong&gt; cada client envia 20 mensagens em sequência, esperando a resposta, todos ao mesmo tempo;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Broadcasts:&lt;/strong&gt; 50 eventos de 100 bytes pra todos os clients de uma vez.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Do lado do PHP, medi duas configurações: o PHP 8.1 como vem, e o PHP 8.5 com OPcache e JIT ligados. Explico o motivo logo depois dos gráficos.&lt;/p&gt;

&lt;figure class=&quot;viz&quot; role=&quot;img&quot; aria-label=&quot;Memória total do processo (RSS) com 1.000, 5.000 e 10.000 clientes: PHP 8.1, PHP 8.5 com JIT e o servidor oficial em Node.js&quot;&gt;
&lt;svg viewBox=&quot;0 0 480 268&quot; xmlns=&quot;http://www.w3.org/2000/svg&quot;&gt;
&lt;rect class=&quot;s1&quot; x=&quot;56&quot; y=&quot;10&quot; width=&quot;12&quot; height=&quot;12&quot; rx=&quot;2&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;74&quot; y=&quot;21&quot;&gt;PHP 8.1&lt;/text&gt;
&lt;rect class=&quot;s3&quot; x=&quot;172&quot; y=&quot;10&quot; width=&quot;12&quot; height=&quot;12&quot; rx=&quot;2&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;190&quot; y=&quot;21&quot;&gt;PHP 8.5 com JIT&lt;/text&gt;
&lt;rect class=&quot;s2&quot; x=&quot;318&quot; y=&quot;10&quot; width=&quot;12&quot; height=&quot;12&quot; rx=&quot;2&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;336&quot; y=&quot;21&quot;&gt;Node.js&lt;/text&gt;
&lt;line class=&quot;grid&quot; x1=&quot;56&quot; y1=&quot;240.0&quot; x2=&quot;470&quot; y2=&quot;240.0&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;244.0&quot; text-anchor=&quot;end&quot;&gt;0&lt;/text&gt;
&lt;line class=&quot;grid&quot; x1=&quot;56&quot; y1=&quot;180.0&quot; x2=&quot;470&quot; y2=&quot;180.0&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;184.0&quot; text-anchor=&quot;end&quot;&gt;100&lt;/text&gt;
&lt;line class=&quot;grid&quot; x1=&quot;56&quot; y1=&quot;120.0&quot; x2=&quot;470&quot; y2=&quot;120.0&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;124.0&quot; text-anchor=&quot;end&quot;&gt;200&lt;/text&gt;
&lt;line class=&quot;grid&quot; x1=&quot;56&quot; y1=&quot;60.0&quot; x2=&quot;470&quot; y2=&quot;60.0&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;64.0&quot; text-anchor=&quot;end&quot;&gt;300&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;46&quot; text-anchor=&quot;end&quot;&gt;MB&lt;/text&gt;
&lt;path class=&quot;s1&quot; d=&quot;M69.0,240 V220.0 Q69.0,216.0 73.0,216.0 H101.0 Q105.0,216.0 105.0,220.0 V240 Z&quot; data-hover&gt;&lt;title&gt;PHP 8.1, 1.000 clientes: 40 MB&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;87.0&quot; y=&quot;210.0&quot; text-anchor=&quot;middle&quot;&gt;40&lt;/text&gt;
&lt;path class=&quot;s3&quot; d=&quot;M107.0,240 V214.6 Q107.0,210.6 111.0,210.6 H139.0 Q143.0,210.6 143.0,214.6 V240 Z&quot; data-hover&gt;&lt;title&gt;PHP 8.5 com JIT, 1.000 clientes: 49 MB&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;125.0&quot; y=&quot;204.6&quot; text-anchor=&quot;middle&quot;&gt;49&lt;/text&gt;
&lt;path class=&quot;s2&quot; d=&quot;M145.0,240 V185.2 Q145.0,181.2 149.0,181.2 H177.0 Q181.0,181.2 181.0,185.2 V240 Z&quot; data-hover&gt;&lt;title&gt;Node.js, 1.000 clientes: 98 MB&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;163.0&quot; y=&quot;175.2&quot; text-anchor=&quot;middle&quot;&gt;98&lt;/text&gt;
&lt;text class=&quot;t&quot; x=&quot;125.0&quot; y=&quot;260&quot; text-anchor=&quot;middle&quot;&gt;1.000 clientes&lt;/text&gt;
&lt;path class=&quot;s1&quot; d=&quot;M207.0,240 V160.0 Q207.0,156.0 211.0,156.0 H239.0 Q243.0,156.0 243.0,160.0 V240 Z&quot; data-hover&gt;&lt;title&gt;PHP 8.1, 5.000 clientes: 140 MB&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;225.0&quot; y=&quot;150.0&quot; text-anchor=&quot;middle&quot;&gt;140&lt;/text&gt;
&lt;path class=&quot;s3&quot; d=&quot;M245.0,240 V157.6 Q245.0,153.6 249.0,153.6 H277.0 Q281.0,153.6 281.0,157.6 V240 Z&quot; data-hover&gt;&lt;title&gt;PHP 8.5 com JIT, 5.000 clientes: 144 MB&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;263.0&quot; y=&quot;147.6&quot; text-anchor=&quot;middle&quot;&gt;144&lt;/text&gt;
&lt;path class=&quot;s2&quot; d=&quot;M283.0,240 V119.8 Q283.0,115.8 287.0,115.8 H315.0 Q319.0,115.8 319.0,119.8 V240 Z&quot; data-hover&gt;&lt;title&gt;Node.js, 5.000 clientes: 207 MB&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;301.0&quot; y=&quot;109.8&quot; text-anchor=&quot;middle&quot;&gt;207&lt;/text&gt;
&lt;text class=&quot;t&quot; x=&quot;263.0&quot; y=&quot;260&quot; text-anchor=&quot;middle&quot;&gt;5.000 clientes&lt;/text&gt;
&lt;path class=&quot;s1&quot; d=&quot;M345.0,240 V86.8 Q345.0,82.8 349.0,82.8 H377.0 Q381.0,82.8 381.0,86.8 V240 Z&quot; data-hover&gt;&lt;title&gt;PHP 8.1, 10.000 clientes: 262 MB&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;363.0&quot; y=&quot;76.8&quot; text-anchor=&quot;middle&quot;&gt;262&lt;/text&gt;
&lt;path class=&quot;s3&quot; d=&quot;M383.0,240 V86.8 Q383.0,82.8 387.0,82.8 H415.0 Q419.0,82.8 419.0,86.8 V240 Z&quot; data-hover&gt;&lt;title&gt;PHP 8.5 com JIT, 10.000 clientes: 262 MB&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;401.0&quot; y=&quot;76.8&quot; text-anchor=&quot;middle&quot;&gt;262&lt;/text&gt;
&lt;path class=&quot;s2&quot; d=&quot;M421.0,240 V78.4 Q421.0,74.4 425.0,74.4 H453.0 Q457.0,74.4 457.0,78.4 V240 Z&quot; data-hover&gt;&lt;title&gt;Node.js, 10.000 clientes: 276 MB&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;439.0&quot; y=&quot;68.4&quot; text-anchor=&quot;middle&quot;&gt;276&lt;/text&gt;
&lt;text class=&quot;t&quot; x=&quot;401.0&quot; y=&quot;260&quot; text-anchor=&quot;middle&quot;&gt;10.000 clientes&lt;/text&gt;
&lt;/svg&gt;
&lt;figcaption&gt;Memória total do processo (RSS), em MB. Menor é melhor.&lt;/figcaption&gt;
&lt;/figure&gt;

&lt;p&gt;Na memória, o PHP fica abaixo em todos os tamanhos. A maior diferença está no início: o processo PHP começa com cerca de 13 MB, e o Node com 64 MB. Com 10 mil clientes a diferença cai pra 5%. Cada conexão custa cerca de 25 KB, e o crescimento é linear. O JIT custa de 8 a 13 MB, uma vez só, não por conexão.&lt;/p&gt;

&lt;figure class=&quot;viz&quot; role=&quot;img&quot; aria-label=&quot;Acknowledgements por segundo com 1.000, 5.000 e 10.000 clientes: PHP 8.1, PHP 8.5 com JIT e Node.js&quot;&gt;
&lt;svg viewBox=&quot;0 0 480 268&quot; xmlns=&quot;http://www.w3.org/2000/svg&quot;&gt;
&lt;rect class=&quot;s1&quot; x=&quot;56&quot; y=&quot;10&quot; width=&quot;12&quot; height=&quot;12&quot; rx=&quot;2&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;74&quot; y=&quot;21&quot;&gt;PHP 8.1&lt;/text&gt;
&lt;rect class=&quot;s3&quot; x=&quot;172&quot; y=&quot;10&quot; width=&quot;12&quot; height=&quot;12&quot; rx=&quot;2&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;190&quot; y=&quot;21&quot;&gt;PHP 8.5 com JIT&lt;/text&gt;
&lt;rect class=&quot;s2&quot; x=&quot;318&quot; y=&quot;10&quot; width=&quot;12&quot; height=&quot;12&quot; rx=&quot;2&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;336&quot; y=&quot;21&quot;&gt;Node.js&lt;/text&gt;
&lt;line class=&quot;grid&quot; x1=&quot;56&quot; y1=&quot;240.0&quot; x2=&quot;470&quot; y2=&quot;240.0&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;244.0&quot; text-anchor=&quot;end&quot;&gt;0&lt;/text&gt;
&lt;line class=&quot;grid&quot; x1=&quot;56&quot; y1=&quot;195.0&quot; x2=&quot;470&quot; y2=&quot;195.0&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;199.0&quot; text-anchor=&quot;end&quot;&gt;25&lt;/text&gt;
&lt;line class=&quot;grid&quot; x1=&quot;56&quot; y1=&quot;150.0&quot; x2=&quot;470&quot; y2=&quot;150.0&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;154.0&quot; text-anchor=&quot;end&quot;&gt;50&lt;/text&gt;
&lt;line class=&quot;grid&quot; x1=&quot;56&quot; y1=&quot;105.0&quot; x2=&quot;470&quot; y2=&quot;105.0&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;109.0&quot; text-anchor=&quot;end&quot;&gt;75&lt;/text&gt;
&lt;line class=&quot;grid&quot; x1=&quot;56&quot; y1=&quot;60.0&quot; x2=&quot;470&quot; y2=&quot;60.0&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;64.0&quot; text-anchor=&quot;end&quot;&gt;100&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;46&quot; text-anchor=&quot;end&quot;&gt;mil/s&lt;/text&gt;
&lt;path class=&quot;s1&quot; d=&quot;M69.0,240 V128.8 Q69.0,124.8 73.0,124.8 H101.0 Q105.0,124.8 105.0,128.8 V240 Z&quot; data-hover&gt;&lt;title&gt;PHP 8.1, 1.000 clientes: 64 mil/s&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;87.0&quot; y=&quot;118.8&quot; text-anchor=&quot;middle&quot;&gt;64&lt;/text&gt;
&lt;path class=&quot;s3&quot; d=&quot;M107.0,240 V132.4 Q107.0,128.4 111.0,128.4 H139.0 Q143.0,128.4 143.0,132.4 V240 Z&quot; data-hover&gt;&lt;title&gt;PHP 8.5 com JIT, 1.000 clientes: 62 mil/s&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;125.0&quot; y=&quot;122.4&quot; text-anchor=&quot;middle&quot;&gt;62&lt;/text&gt;
&lt;path class=&quot;s2&quot; d=&quot;M145.0,240 V123.4 Q145.0,119.4 149.0,119.4 H177.0 Q181.0,119.4 181.0,123.4 V240 Z&quot; data-hover&gt;&lt;title&gt;Node.js, 1.000 clientes: 67 mil/s&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;163.0&quot; y=&quot;113.4&quot; text-anchor=&quot;middle&quot;&gt;67&lt;/text&gt;
&lt;text class=&quot;t&quot; x=&quot;125.0&quot; y=&quot;260&quot; text-anchor=&quot;middle&quot;&gt;1.000 clientes&lt;/text&gt;
&lt;path class=&quot;s1&quot; d=&quot;M207.0,240 V103.6 Q207.0,99.6 211.0,99.6 H239.0 Q243.0,99.6 243.0,103.6 V240 Z&quot; data-hover&gt;&lt;title&gt;PHP 8.1, 5.000 clientes: 78 mil/s&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;225.0&quot; y=&quot;93.6&quot; text-anchor=&quot;middle&quot;&gt;78&lt;/text&gt;
&lt;path class=&quot;s3&quot; d=&quot;M245.0,240 V71.2 Q245.0,67.2 249.0,67.2 H277.0 Q281.0,67.2 281.0,71.2 V240 Z&quot; data-hover&gt;&lt;title&gt;PHP 8.5 com JIT, 5.000 clientes: 96 mil/s&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;263.0&quot; y=&quot;61.2&quot; text-anchor=&quot;middle&quot;&gt;96&lt;/text&gt;
&lt;path class=&quot;s2&quot; d=&quot;M283.0,240 V73.0 Q283.0,69.0 287.0,69.0 H315.0 Q319.0,69.0 319.0,73.0 V240 Z&quot; data-hover&gt;&lt;title&gt;Node.js, 5.000 clientes: 95 mil/s&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;301.0&quot; y=&quot;63.0&quot; text-anchor=&quot;middle&quot;&gt;95&lt;/text&gt;
&lt;text class=&quot;t&quot; x=&quot;263.0&quot; y=&quot;260&quot; text-anchor=&quot;middle&quot;&gt;5.000 clientes&lt;/text&gt;
&lt;path class=&quot;s1&quot; d=&quot;M345.0,240 V114.4 Q345.0,110.4 349.0,110.4 H377.0 Q381.0,110.4 381.0,114.4 V240 Z&quot; data-hover&gt;&lt;title&gt;PHP 8.1, 10.000 clientes: 72 mil/s&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;363.0&quot; y=&quot;104.4&quot; text-anchor=&quot;middle&quot;&gt;72&lt;/text&gt;
&lt;path class=&quot;s3&quot; d=&quot;M383.0,240 V87.4 Q383.0,83.4 387.0,83.4 H415.0 Q419.0,83.4 419.0,87.4 V240 Z&quot; data-hover&gt;&lt;title&gt;PHP 8.5 com JIT, 10.000 clientes: 87 mil/s&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;401.0&quot; y=&quot;77.4&quot; text-anchor=&quot;middle&quot;&gt;87&lt;/text&gt;
&lt;path class=&quot;s2&quot; d=&quot;M421.0,240 V76.6 Q421.0,72.6 425.0,72.6 H453.0 Q457.0,72.6 457.0,76.6 V240 Z&quot; data-hover&gt;&lt;title&gt;Node.js, 10.000 clientes: 93 mil/s&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;439.0&quot; y=&quot;66.6&quot; text-anchor=&quot;middle&quot;&gt;93&lt;/text&gt;
&lt;text class=&quot;t&quot; x=&quot;401.0&quot; y=&quot;260&quot; text-anchor=&quot;middle&quot;&gt;10.000 clientes&lt;/text&gt;
&lt;/svg&gt;
&lt;figcaption&gt;Acknowledgements (echo) por segundo, em milhares. Maior é melhor.&lt;/figcaption&gt;
&lt;/figure&gt;

&lt;p&gt;Nos acknowledgements, com mil clientes os três ficam dentro da variação normal entre execuções. A partir de 5 mil, o PHP 8.1 fica pra trás: o Node responde de 21% a 29% mais por segundo. Com JIT, o PHP empata com 5 mil clientes e fica 7% abaixo com 10 mil.&lt;/p&gt;

&lt;figure class=&quot;viz&quot; role=&quot;img&quot; aria-label=&quot;Entregas de broadcast por segundo com 1.000, 5.000 e 10.000 clientes: PHP 8.1, PHP 8.5 com JIT e Node.js&quot;&gt;
&lt;svg viewBox=&quot;0 0 480 268&quot; xmlns=&quot;http://www.w3.org/2000/svg&quot;&gt;
&lt;rect class=&quot;s1&quot; x=&quot;56&quot; y=&quot;10&quot; width=&quot;12&quot; height=&quot;12&quot; rx=&quot;2&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;74&quot; y=&quot;21&quot;&gt;PHP 8.1&lt;/text&gt;
&lt;rect class=&quot;s3&quot; x=&quot;172&quot; y=&quot;10&quot; width=&quot;12&quot; height=&quot;12&quot; rx=&quot;2&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;190&quot; y=&quot;21&quot;&gt;PHP 8.5 com JIT&lt;/text&gt;
&lt;rect class=&quot;s2&quot; x=&quot;318&quot; y=&quot;10&quot; width=&quot;12&quot; height=&quot;12&quot; rx=&quot;2&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;336&quot; y=&quot;21&quot;&gt;Node.js&lt;/text&gt;
&lt;line class=&quot;grid&quot; x1=&quot;56&quot; y1=&quot;240.0&quot; x2=&quot;470&quot; y2=&quot;240.0&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;244.0&quot; text-anchor=&quot;end&quot;&gt;0&lt;/text&gt;
&lt;line class=&quot;grid&quot; x1=&quot;56&quot; y1=&quot;210.0&quot; x2=&quot;470&quot; y2=&quot;210.0&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;214.0&quot; text-anchor=&quot;end&quot;&gt;100&lt;/text&gt;
&lt;line class=&quot;grid&quot; x1=&quot;56&quot; y1=&quot;180.0&quot; x2=&quot;470&quot; y2=&quot;180.0&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;184.0&quot; text-anchor=&quot;end&quot;&gt;200&lt;/text&gt;
&lt;line class=&quot;grid&quot; x1=&quot;56&quot; y1=&quot;150.0&quot; x2=&quot;470&quot; y2=&quot;150.0&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;154.0&quot; text-anchor=&quot;end&quot;&gt;300&lt;/text&gt;
&lt;line class=&quot;grid&quot; x1=&quot;56&quot; y1=&quot;120.0&quot; x2=&quot;470&quot; y2=&quot;120.0&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;124.0&quot; text-anchor=&quot;end&quot;&gt;400&lt;/text&gt;
&lt;line class=&quot;grid&quot; x1=&quot;56&quot; y1=&quot;90.0&quot; x2=&quot;470&quot; y2=&quot;90.0&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;94.0&quot; text-anchor=&quot;end&quot;&gt;500&lt;/text&gt;
&lt;line class=&quot;grid&quot; x1=&quot;56&quot; y1=&quot;60.0&quot; x2=&quot;470&quot; y2=&quot;60.0&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;64.0&quot; text-anchor=&quot;end&quot;&gt;600&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;46&quot; text-anchor=&quot;end&quot;&gt;mil/s&lt;/text&gt;
&lt;path class=&quot;s1&quot; d=&quot;M69.0,240 V117.4 Q69.0,113.4 73.0,113.4 H101.0 Q105.0,113.4 105.0,117.4 V240 Z&quot; data-hover&gt;&lt;title&gt;PHP 8.1, 1.000 clientes: 422 mil/s&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;87.0&quot; y=&quot;107.4&quot; text-anchor=&quot;middle&quot;&gt;422&lt;/text&gt;
&lt;path class=&quot;s3&quot; d=&quot;M107.0,240 V82.6 Q107.0,78.6 111.0,78.6 H139.0 Q143.0,78.6 143.0,82.6 V240 Z&quot; data-hover&gt;&lt;title&gt;PHP 8.5 com JIT, 1.000 clientes: 538 mil/s&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;125.0&quot; y=&quot;72.6&quot; text-anchor=&quot;middle&quot;&gt;538&lt;/text&gt;
&lt;path class=&quot;s2&quot; d=&quot;M145.0,240 V83.5 Q145.0,79.5 149.0,79.5 H177.0 Q181.0,79.5 181.0,83.5 V240 Z&quot; data-hover&gt;&lt;title&gt;Node.js, 1.000 clientes: 535 mil/s&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;163.0&quot; y=&quot;73.5&quot; text-anchor=&quot;middle&quot;&gt;535&lt;/text&gt;
&lt;text class=&quot;t&quot; x=&quot;125.0&quot; y=&quot;260&quot; text-anchor=&quot;middle&quot;&gt;1.000 clientes&lt;/text&gt;
&lt;path class=&quot;s1&quot; d=&quot;M207.0,240 V118.0 Q207.0,114.0 211.0,114.0 H239.0 Q243.0,114.0 243.0,118.0 V240 Z&quot; data-hover&gt;&lt;title&gt;PHP 8.1, 5.000 clientes: 420 mil/s&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;225.0&quot; y=&quot;108.0&quot; text-anchor=&quot;middle&quot;&gt;420&lt;/text&gt;
&lt;path class=&quot;s3&quot; d=&quot;M245.0,240 V80.2 Q245.0,76.2 249.0,76.2 H277.0 Q281.0,76.2 281.0,80.2 V240 Z&quot; data-hover&gt;&lt;title&gt;PHP 8.5 com JIT, 5.000 clientes: 546 mil/s&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;263.0&quot; y=&quot;70.2&quot; text-anchor=&quot;middle&quot;&gt;546&lt;/text&gt;
&lt;path class=&quot;s2&quot; d=&quot;M283.0,240 V65.2 Q283.0,61.2 287.0,61.2 H315.0 Q319.0,61.2 319.0,65.2 V240 Z&quot; data-hover&gt;&lt;title&gt;Node.js, 5.000 clientes: 596 mil/s&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;301.0&quot; y=&quot;55.2&quot; text-anchor=&quot;middle&quot;&gt;596&lt;/text&gt;
&lt;text class=&quot;t&quot; x=&quot;263.0&quot; y=&quot;260&quot; text-anchor=&quot;middle&quot;&gt;5.000 clientes&lt;/text&gt;
&lt;path class=&quot;s1&quot; d=&quot;M345.0,240 V124.0 Q345.0,120.0 349.0,120.0 H377.0 Q381.0,120.0 381.0,124.0 V240 Z&quot; data-hover&gt;&lt;title&gt;PHP 8.1, 10.000 clientes: 400 mil/s&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;363.0&quot; y=&quot;114.0&quot; text-anchor=&quot;middle&quot;&gt;400&lt;/text&gt;
&lt;path class=&quot;s3&quot; d=&quot;M383.0,240 V98.2 Q383.0,94.2 387.0,94.2 H415.0 Q419.0,94.2 419.0,98.2 V240 Z&quot; data-hover&gt;&lt;title&gt;PHP 8.5 com JIT, 10.000 clientes: 486 mil/s&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;401.0&quot; y=&quot;88.2&quot; text-anchor=&quot;middle&quot;&gt;486&lt;/text&gt;
&lt;path class=&quot;s2&quot; d=&quot;M421.0,240 V95.5 Q421.0,91.5 425.0,91.5 H453.0 Q457.0,91.5 457.0,95.5 V240 Z&quot; data-hover&gt;&lt;title&gt;Node.js, 10.000 clientes: 495 mil/s&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;439.0&quot; y=&quot;85.5&quot; text-anchor=&quot;middle&quot;&gt;495&lt;/text&gt;
&lt;text class=&quot;t&quot; x=&quot;401.0&quot; y=&quot;260&quot; text-anchor=&quot;middle&quot;&gt;10.000 clientes&lt;/text&gt;
&lt;/svg&gt;
&lt;figcaption&gt;Entregas de broadcast por segundo, em milhares. Maior é melhor.&lt;/figcaption&gt;
&lt;/figure&gt;

&lt;p&gt;Nos broadcasts acontece o mesmo. Sem JIT, o Node entrega de 1,2 a 1,4 vez mais por segundo. Com JIT, o PHP empata com mil e 10 mil clientes e fica 8% abaixo com 5 mil.&lt;/p&gt;

&lt;p&gt;Throughput não diz quanto tempo uma mensagem leva pra chegar. Pra isso medi a latência de um broadcast pra uma room de mil clientes, com 10 mil conectados: 100 mensagens, uma a cada 50 ms, cronometradas do pedido até a chegada em cada membro. Os clients ficam espalhados em 10 containers, mil em cada, pra que nenhum processo de client vire o gargalo. O p99 é o tempo em que 99% das entregas já chegaram.&lt;/p&gt;

&lt;figure class=&quot;viz&quot; role=&quot;img&quot; aria-label=&quot;Latência de broadcast para uma room de 1.000 clientes, com 10.000 conectados: p50 e p99 do PHP 8.1, do PHP 8.5 com JIT e do Node.js&quot;&gt;
&lt;svg viewBox=&quot;0 0 480 268&quot; xmlns=&quot;http://www.w3.org/2000/svg&quot;&gt;
&lt;rect class=&quot;s1&quot; x=&quot;56&quot; y=&quot;10&quot; width=&quot;12&quot; height=&quot;12&quot; rx=&quot;2&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;74&quot; y=&quot;21&quot;&gt;PHP 8.1&lt;/text&gt;
&lt;rect class=&quot;s3&quot; x=&quot;172&quot; y=&quot;10&quot; width=&quot;12&quot; height=&quot;12&quot; rx=&quot;2&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;190&quot; y=&quot;21&quot;&gt;PHP 8.5 com JIT&lt;/text&gt;
&lt;rect class=&quot;s2&quot; x=&quot;318&quot; y=&quot;10&quot; width=&quot;12&quot; height=&quot;12&quot; rx=&quot;2&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;336&quot; y=&quot;21&quot;&gt;Node.js&lt;/text&gt;
&lt;line class=&quot;grid&quot; x1=&quot;56&quot; y1=&quot;240.0&quot; x2=&quot;470&quot; y2=&quot;240.0&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;244.0&quot; text-anchor=&quot;end&quot;&gt;0&lt;/text&gt;
&lt;line class=&quot;grid&quot; x1=&quot;56&quot; y1=&quot;195.0&quot; x2=&quot;470&quot; y2=&quot;195.0&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;199.0&quot; text-anchor=&quot;end&quot;&gt;5&lt;/text&gt;
&lt;line class=&quot;grid&quot; x1=&quot;56&quot; y1=&quot;150.0&quot; x2=&quot;470&quot; y2=&quot;150.0&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;154.0&quot; text-anchor=&quot;end&quot;&gt;10&lt;/text&gt;
&lt;line class=&quot;grid&quot; x1=&quot;56&quot; y1=&quot;105.0&quot; x2=&quot;470&quot; y2=&quot;105.0&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;109.0&quot; text-anchor=&quot;end&quot;&gt;15&lt;/text&gt;
&lt;line class=&quot;grid&quot; x1=&quot;56&quot; y1=&quot;60.0&quot; x2=&quot;470&quot; y2=&quot;60.0&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;64.0&quot; text-anchor=&quot;end&quot;&gt;20&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;50&quot; y=&quot;46&quot; text-anchor=&quot;end&quot;&gt;ms&lt;/text&gt;
&lt;path class=&quot;s1&quot; d=&quot;M103.5,240 V177.9 Q103.5,173.9 107.5,173.9 H135.5 Q139.5,173.9 139.5,177.9 V240 Z&quot; data-hover&gt;&lt;title&gt;PHP 8.1, p50: 7,3 ms&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;121.5&quot; y=&quot;167.9&quot; text-anchor=&quot;middle&quot;&gt;7,3&lt;/text&gt;
&lt;path class=&quot;s3&quot; d=&quot;M141.5,240 V181.7 Q141.5,177.7 145.5,177.7 H173.5 Q177.5,177.7 177.5,181.7 V240 Z&quot; data-hover&gt;&lt;title&gt;PHP 8.5 com JIT, p50: 6,9 ms&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;159.5&quot; y=&quot;171.7&quot; text-anchor=&quot;middle&quot;&gt;6,9&lt;/text&gt;
&lt;path class=&quot;s2&quot; d=&quot;M179.5,240 V187.4 Q179.5,183.4 183.5,183.4 H211.5 Q215.5,183.4 215.5,187.4 V240 Z&quot; data-hover&gt;&lt;title&gt;Node.js, p50: 6,3 ms&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;197.5&quot; y=&quot;177.4&quot; text-anchor=&quot;middle&quot;&gt;6,3&lt;/text&gt;
&lt;text class=&quot;t&quot; x=&quot;159.5&quot; y=&quot;260&quot; text-anchor=&quot;middle&quot;&gt;p50 (metade das entregas)&lt;/text&gt;
&lt;path class=&quot;s1&quot; d=&quot;M310.5,240 V114.7 Q310.5,110.7 314.5,110.7 H342.5 Q346.5,110.7 346.5,114.7 V240 Z&quot; data-hover&gt;&lt;title&gt;PHP 8.1, p99: 14,4 ms&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;328.5&quot; y=&quot;104.7&quot; text-anchor=&quot;middle&quot;&gt;14,4&lt;/text&gt;
&lt;path class=&quot;s3&quot; d=&quot;M348.5,240 V116.4 Q348.5,112.4 352.5,112.4 H380.5 Q384.5,112.4 384.5,116.4 V240 Z&quot; data-hover&gt;&lt;title&gt;PHP 8.5 com JIT, p99: 14,2 ms&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;366.5&quot; y=&quot;106.4&quot; text-anchor=&quot;middle&quot;&gt;14,2&lt;/text&gt;
&lt;path class=&quot;s2&quot; d=&quot;M386.5,240 V118.3 Q386.5,114.3 390.5,114.3 H418.5 Q422.5,114.3 422.5,118.3 V240 Z&quot; data-hover&gt;&lt;title&gt;Node.js, p99: 14,0 ms&lt;/title&gt;&lt;/path&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;404.5&quot; y=&quot;108.3&quot; text-anchor=&quot;middle&quot;&gt;14,0&lt;/text&gt;
&lt;text class=&quot;t&quot; x=&quot;366.5&quot; y=&quot;260&quot; text-anchor=&quot;middle&quot;&gt;p99 (99% das entregas)&lt;/text&gt;
&lt;/svg&gt;
&lt;figcaption&gt;Latência de broadcast pra uma room de mil clientes, com 10 mil conectados, em milissegundos. Menor é melhor.&lt;/figcaption&gt;
&lt;/figure&gt;

&lt;p&gt;Os três ficam praticamente iguais, por volta de 7 ms no p50 e 14 ms no p99, uma diferença abaixo da variação entre execuções. Nessa carga, nenhum dos servidores é o gargalo: servidor e clients dividem a mesma máquina e a rede do Docker, e é esse ambiente que define o tempo. Pra separar um servidor do outro, seria preciso rodar os clients em outras máquinas.&lt;/p&gt;

&lt;p&gt;O PHP deixa o OPcache desligado na linha de comando (&lt;code&gt;opcache.enable_cli=0&lt;/code&gt;), e um servidor Workerman é um processo CLI. Ou seja, sem configurar nada, ele roda interpretado, enquanto o V8, motor do Node, compila com JIT o código mais executado sem precisar configurar nada. Pra uma comparação justa, o JIT precisa estar ligado:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-ini&quot;&gt;; do PHP 8.1 ao 8.4 também precisa de zend_extension=opcache, o 8.5 já vem com ele
opcache.enable_cli=1
opcache.jit=tracing
opcache.jit_buffer_size=128M
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Comparar o PHP 8.1 sem JIT com o 8.5 com JIT muda duas coisas de uma vez, então medi também as outras duas combinações. O ganho vem do JIT, não da versão: com JIT, o PHP 8.1 responde 94 mil acknowledgements por segundo com 5 mil clientes e 85 mil com 10 mil, quase o mesmo que o 8.5 (96 mil e 87 mil). Já o 8.5 sem JIT fica no mesmo nível do 8.1 nos acknowledgements e entrega de 4% a 14% mais broadcasts.&lt;/p&gt;

&lt;p&gt;O profiler mostra onde o JIT age. O maior custo de uma entrega é a chamada de sistema de escrita no socket (cerca de 1,5 µs), o Workerman adiciona uns 0,25 µs e o código do pacote cerca de 0,6 µs. O JIT só acelera essa última parte. Por isso um único evento pra 10 mil clientes, que é basicamente uma escrita por client, quase não muda: 133 mil entregas por segundo sem JIT, 138 mil com, e 154 mil no Node.&lt;/p&gt;

&lt;p&gt;A metodologia completa e os scripts pra rodar na sua máquina estão em &lt;a href=&quot;https://github.com/marcosmarcolin/socket.io-server/blob/main/docs/performance.md&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;docs/performance.md&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;soak-test&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Teste de carga contínua sem vazar memória&lt;/h2&gt;

&lt;p&gt;Um servidor de WebSocket fica dias no ar, então a memória precisa ficar estável enquanto os clients entram e saem. O soak test simula isso: milhares de clients conectando e saindo, por long-polling, WebSocket ou upgrade, com dados binários e rooms, e 30% deles derrubando o transporte pra testar a recuperação. A cada 200 ms sai um broadcast numerado, e cada client confere se perdeu, repetiu ou recebeu algo fora de ordem.&lt;/p&gt;

&lt;p&gt;O resultado de 20 minutos com 2 mil clientes (cerca de 1.850 conectados ao mesmo tempo):&lt;/p&gt;

&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
  &lt;th&gt;&lt;/th&gt;
  &lt;th&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
  &lt;td&gt;Conexões abertas&lt;/td&gt;
  &lt;td&gt;81.615 (cerca de 68 por segundo)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;Transportes derrubados&lt;/td&gt;
  &lt;td&gt;17.615, com 17.560 recuperados e nenhuma falha (o resto encerrou antes)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;Mensagens numeradas recebidas&lt;/td&gt;
  &lt;td&gt;11.012.036, nenhuma perdida, repetida ou fora de ordem&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;Memória (heap) durante o teste&lt;/td&gt;
  &lt;td&gt;de 53,1 a 54,8 MB, estável do início ao fim&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;Memória depois que os clients saíram&lt;/td&gt;
  &lt;td&gt;7,8 MB&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;

&lt;p&gt;O mais útil foi o que ele encontrou antes de passar: até a versão 0.5.1, cada conexão encerrada deixava uns 7 KB pra trás, porque o mapa de sessões pra clients nunca era limpo. A memória ia de 66 MB a 812 MB em 17 minutos, com a CPU em 100%. Nenhum teste unitário pegou isso. A correção saiu na 0.5.2.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;construindo-com-ia&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Como foi construir com IA&lt;/h2&gt;

&lt;p&gt;Construí o pacote junto com o Claude (Opus 5.5). O que tornou isso viável foi o problema ter uma referência clara: o protocolo é documentado, o servidor oficial serve de comparação e as suítes de conformidade dizem objetivamente se a implementação está certa. Cada etapa tinha um critério de pronto que não dependia da opinião de ninguém, nem minha nem da IA.&lt;/p&gt;

&lt;p&gt;O que eu levo dessa experiência:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Testes de verdade valem mais que revisão.&lt;/strong&gt; O código passava em todos os testes e tinha um vazamento de memória. Só o soak test encontrou;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Bugs intermitentes exigem paciência.&lt;/strong&gt; Um teste da suíte oficial falhava uma vez a cada 60 execuções. A causa: o &lt;code&gt;select()&lt;/code&gt; do Workerman lê os sockets prontos na ordem do descritor, não na ordem de chegada, então uma requisição de polling enviada logo depois do upgrade às vezes era lida antes dele. Achar isso deu mais trabalho que muita feature inteira;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Medir antes de otimizar.&lt;/strong&gt; As otimizações do pacote vieram de profiling, não de palpite. Agrupar as escritas de cada conexão dobrou as entregas de broadcast, mas agrupar inclusive a primeira escrita deixou um único evento pra muitos clients 30% mais lento e foi descartado.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a id=&quot;proximos-passos&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Estado atual e próximos passos&lt;/h2&gt;

&lt;p&gt;O pacote está no &lt;a href=&quot;https://packagist.org/packages/marcosmarcolin/socket.io-server&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;Packagist&lt;/a&gt;, na versão 0.x, e funciona do PHP 8.1 ao 8.5, e também com o event loop do Swoole, a extensão de programação assíncrona pra PHP, pra quem já usa. O próximo passo é ver ele rodando em aplicações reais. Também &lt;a href=&quot;https://github.com/socketio/socket.io-website/pull/556&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;abri um pull request&lt;/a&gt; pedindo pra incluir o pacote, junto com o phpsocket.io, na lista de implementações de servidor do site do Socket.IO, que ainda aguarda revisão.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;conclusao&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Conclusão&lt;/h2&gt;

&lt;p&gt;Com o socket.io-server, uma aplicação PHP não precisa mais de um serviço em Node.js do lado só pra usar a versão atual do Socket.IO. Dá pra manter tudo na mesma stack, com o client oficial e os recursos que vieram depois da 2.x.&lt;/p&gt;

&lt;p&gt;Dois aprendizados valem mesmo pra quem nunca vai usar o pacote. Se você roda PHP de longa duração na linha de comando, confira se o OPcache e o JIT estão ligados, porque por padrão não estão. E teste de carga contínua pega o que teste unitário não pega.&lt;/p&gt;

&lt;p&gt;Pra testar, o guia de migração e os exemplos do repositório são um bom ponto de partida.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;perguntas-frequentes&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Perguntas frequentes&lt;/h2&gt;

&lt;h3&gt;Dá pra usar Socket.IO v4 com PHP?&lt;/h3&gt;

&lt;p&gt;Sim. O socket.io-server é um servidor Socket.IO v4 em PHP, feito sobre o Workerman, que funciona com o &lt;code&gt;socket.io-client&lt;/code&gt; oficial v3 e v4. Ele roda como um processo PHP de longa duração, separado do PHP-FPM.&lt;/p&gt;

&lt;h3&gt;O phpsocket.io suporta o socket.io-client v3 e v4?&lt;/h3&gt;

&lt;p&gt;Não. O phpsocket.io implementa o Engine.IO v3 e só funciona com os clients 1.x e 2.x. Pra v3 e v4, o próprio README do phpsocket.io indica o socket.io-server, que tem um guia de migração.&lt;/p&gt;

&lt;h2&gt;Links&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://github.com/marcosmarcolin/socket.io-server&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;socket.io-server no GitHub&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://packagist.org/packages/marcosmarcolin/socket.io-server&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;socket.io-server no Packagist&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://github.com/marcosmarcolin/socket.io-server/blob/main/docs/performance.md&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;Performance e limites (metodologia completa)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://github.com/marcosmarcolin/socket.io-server/blob/main/docs/migrating-from-phpsocket.io.md&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;Guia de migração do phpsocket.io&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://github.com/walkor/phpsocket.io&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;phpsocket.io&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://socket.io/docs/v4/&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;Documentação do Socket.IO v4&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content>
        </entry>
            <entry>
            <id>https://www.marcosmarcolin.com.br/blog/php2shell-vulnerabilidade-critica-no-php</id>
            <link type="text/html" rel="alternate" href="https://www.marcosmarcolin.com.br/blog/php2shell-vulnerabilidade-critica-no-php" />
            <title>PHP2Shell: a falha crítica no PHP e como se proteger</title>
            <published>2026-10-27T00:00:00+00:00</published>
            <updated>2026-11-20T00:00:00+00:00</updated>
            <author>
                <name>Marcos Marcolin</name>
            </author>
            <summary type="html">Entenda o PHP2Shell (CVE-2026-109618 e CVE-2026-109619): a gravidade real, o que era exagero e como saber se seu servidor está vulnerável.</summary>
            <content type="html">&lt;p&gt;E não é que o PHP voltou a ser um dos assuntos mais comentados da internet mundial? 🐘&lt;/p&gt;

&lt;p&gt;Quem diz que o PHP morreu deve ter levado um susto: na semana passada ele apareceu no g1 e na CNN, fez governos na Europa tirarem sites do ar e até o FBI e a NSA soltaram alerta. Só que, dessa vez, o motivo não foi uma feature nova.&lt;/p&gt;

&lt;p&gt;O PHP lançou uma release de emergência pra corrigir duas vulnerabilidades que permitem &lt;strong&gt;execução remota de código sem autenticação&lt;/strong&gt;, apelidadas de &lt;strong&gt;PHP2Shell&lt;/strong&gt;: a CVE-2026-109618 e a CVE-2026-109619.&lt;/p&gt;

&lt;p&gt;Se você não tiver tempo pra ler o resto, leve só isso: &lt;strong&gt;se o seu servidor roda PHP atendendo requisições web, atualize para 8.5.12, 8.4.27, 8.3.36 ou 8.2.35 (ou superior).&lt;/strong&gt;&lt;/p&gt;

&lt;blockquote&gt;
  &lt;p&gt;&lt;strong&gt;Atualização:&lt;/strong&gt; em 19/11, o PHP corrigiu mais 17 falhas, e algumas delas são continuações do PHP2Shell. As versões mínimas agora são 8.5.13, 8.4.28, 8.3.37 e 8.2.36. Os detalhes estão no post &lt;a href=&quot;/blog/php-falhas-seguranca-novembro-2026&quot;&gt;PHP corrige 7 falhas críticas: o que fazer com o 8.5.13 e o 8.4.28&lt;/a&gt;.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;Sumário&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;#o-que-e-uma-cve&quot;&gt;Antes, o que é uma CVE?&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#o-que-aconteceu&quot;&gt;O que aconteceu&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#as-duas-falhas&quot;&gt;As duas falhas&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#quem-esta-em-risco&quot;&gt;Quem está em risco e qual a gravidade?&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#fake-news&quot;&gt;Fake news e exageros&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#a-correcao&quot;&gt;Como o PHP corrigiu&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#como-saber-se-estou-vulneravel&quot;&gt;Como saber se estou vulnerável?&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#nao-consigo-atualizar-agora&quot;&gt;Não consigo atualizar agora, e aí?&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#o-php-vai-morrer&quot;&gt;Então o PHP acabou? Claro que não&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#manter-atualizado&quot;&gt;Manter atualizado não é opcional&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#conclusao&quot;&gt;Conclusão&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a id=&quot;o-que-e-uma-cve&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Antes, o que é uma CVE?&lt;/h2&gt;

&lt;p&gt;Se você nunca precisou lidar com isso, três siglas vão aparecer bastante por aqui:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;CVE&lt;/strong&gt; (&lt;em&gt;Common Vulnerabilities and Exposures&lt;/em&gt;) é o &quot;RG&quot; de uma falha de segurança. Cada vulnerabilidade conhecida recebe um identificador único, como &lt;code&gt;CVE-2026-109618&lt;/code&gt;: o ano e um número. Assim, todo mundo (desenvolvedores, empresas, distros e ferramentas de segurança) fala da mesma falha sem confusão;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;CVSS&lt;/strong&gt; (&lt;em&gt;Common Vulnerability Scoring System&lt;/em&gt;) é a nota de gravidade, de 0 a 10. Acima de 9 é considerada crítica;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;RCE&lt;/strong&gt; (&lt;em&gt;Remote Code Execution&lt;/em&gt;) é o pior tipo de falha: o atacante consegue executar código no seu servidor pela rede, como se tivesse acesso a ele.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Ou seja, quando alguém diz &quot;CVE crítica com RCE&quot;, está dizendo: falha catalogada, gravidade na faixa mais alta da escala, e o atacante pode assumir o servidor.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;o-que-aconteceu&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;O que aconteceu&lt;/h2&gt;

&lt;figure class=&quot;viz&quot; role=&quot;img&quot; aria-label=&quot;Linha do tempo do PHP2Shell entre 17 e 26 de outubro de 2026&quot;&gt;
&lt;svg viewBox=&quot;0 0 480 350&quot; xmlns=&quot;http://www.w3.org/2000/svg&quot;&gt;
&lt;line class=&quot;grid&quot; x1=&quot;110&quot; y1=&quot;30&quot; x2=&quot;110&quot; y2=&quot;320&quot;/&gt;
&lt;circle class=&quot;s2&quot; cx=&quot;110&quot; cy=&quot;30&quot; r=&quot;7&quot; data-hover&gt;&lt;title&gt;17/10: tentativa de exploração registrada pela Amazon&lt;/title&gt;&lt;/circle&gt;
&lt;text class=&quot;t-b&quot; x=&quot;95&quot; y=&quot;34&quot; text-anchor=&quot;end&quot;&gt;17/10&lt;/text&gt;
&lt;text class=&quot;t&quot; x=&quot;125&quot; y=&quot;34&quot;&gt;Amazon registra tentativa de exploração&lt;/text&gt;
&lt;circle class=&quot;s2&quot; cx=&quot;110&quot; cy=&quot;88&quot; r=&quot;7&quot; data-hover&gt;&lt;title&gt;20/10: os IDs das CVEs vazam com nota errada e um vídeo do PoC é publicado por engano&lt;/title&gt;&lt;/circle&gt;
&lt;text class=&quot;t-b&quot; x=&quot;95&quot; y=&quot;92&quot; text-anchor=&quot;end&quot;&gt;20/10&lt;/text&gt;
&lt;text class=&quot;t&quot; x=&quot;125&quot; y=&quot;92&quot;&gt;IDs das CVEs vazam com nota errada (10)&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;125&quot; y=&quot;108&quot;&gt;Vídeo do PoC é publicado por engano&lt;/text&gt;
&lt;circle class=&quot;s1&quot; cx=&quot;110&quot; cy=&quot;146&quot; r=&quot;7&quot; data-hover&gt;&lt;title&gt;21/10: PHP 8.5.12, 8.4.27, 8.3.36 e 8.2.35&lt;/title&gt;&lt;/circle&gt;
&lt;text class=&quot;t-b&quot; x=&quot;95&quot; y=&quot;150&quot; text-anchor=&quot;end&quot;&gt;21/10&lt;/text&gt;
&lt;text class=&quot;t&quot; x=&quot;125&quot; y=&quot;150&quot;&gt;Correção: 8.5.12, 8.4.27, 8.3.36, 8.2.35&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;125&quot; y=&quot;166&quot;&gt;Advisories publicados no GitHub&lt;/text&gt;
&lt;circle class=&quot;s1&quot; cx=&quot;110&quot; cy=&quot;204&quot; r=&quot;7&quot; data-hover&gt;&lt;title&gt;23/10: aviso informativo sobre a CVE-2026-115560&lt;/title&gt;&lt;/circle&gt;
&lt;text class=&quot;t-b&quot; x=&quot;95&quot; y=&quot;208&quot; text-anchor=&quot;end&quot;&gt;23/10&lt;/text&gt;
&lt;text class=&quot;t&quot; x=&quot;125&quot; y=&quot;208&quot;&gt;Aviso sobre a CVE-2026-115560&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;125&quot; y=&quot;224&quot;&gt;Configuração incomum, mitigação simples&lt;/text&gt;
&lt;circle class=&quot;s2&quot; cx=&quot;110&quot; cy=&quot;262&quot; r=&quot;7&quot; data-hover&gt;&lt;title&gt;24/10: RCE confirmada em honeypot&lt;/title&gt;&lt;/circle&gt;
&lt;text class=&quot;t-b&quot; x=&quot;95&quot; y=&quot;266&quot; text-anchor=&quot;end&quot;&gt;24/10&lt;/text&gt;
&lt;text class=&quot;t&quot; x=&quot;125&quot; y=&quot;266&quot;&gt;RCE confirmada em honeypot&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;125&quot; y=&quot;282&quot;&gt;Apache mod_php com PHP 8.4.26&lt;/text&gt;
&lt;circle class=&quot;s2&quot; cx=&quot;110&quot; cy=&quot;320&quot; r=&quot;7&quot; data-hover&gt;&lt;title&gt;26/10: CISA adiciona as CVEs ao catálogo KEV&lt;/title&gt;&lt;/circle&gt;
&lt;text class=&quot;t-b&quot; x=&quot;95&quot; y=&quot;324&quot; text-anchor=&quot;end&quot;&gt;26/10&lt;/text&gt;
&lt;text class=&quot;t&quot; x=&quot;125&quot; y=&quot;324&quot;&gt;CISA coloca no catálogo KEV&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;125&quot; y=&quot;340&quot;&gt;Vulnerabilidades exploradas ativamente&lt;/text&gt;
&lt;/svg&gt;
&lt;figcaption&gt;Laranja: ataque ou vazamento. Azul: resposta do PHP.&lt;/figcaption&gt;
&lt;/figure&gt;

&lt;p&gt;A release estava marcada para 22/10, mas no dia 20 os IDs das CVEs vazaram nas redes com uma nota errada, e logo depois a Calif, empresa que reportou as falhas, publicou por engano um vídeo do exploit. O PHP antecipou tudo em um dia.&lt;/p&gt;

&lt;p&gt;Aí o assunto saiu da bolha dev. O CERT-EU recomendou tirar do ar os sites afetados, e governos da Finlândia, Holanda, França e Alemanha desligaram páginas oficiais. Nos Estados Unidos, o &lt;a href=&quot;https://x.com/FBICyberDiv/status/2112921648252719420&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;FBI publicou um alerta&lt;/a&gt; recomendando atualizar imediatamente e, se não der, tirar o sistema do ar. Aqui no Brasil, a Anatel e tribunais suspenderam o SEI por precaução. A imprensa toda cobriu, inclusive o g1, que contou &lt;a href=&quot;https://g1.globo.com/tecnologia/ciberseguranca/noticia/2026/10/23/brecha-no-php-que-tirou-sites-do-ar-foi-descoberta-ha-dois-anos-responsavel-cita-falta-de-recursos-para-corrigi-la.ghtml&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;que a brecha foi descoberta há dois anos&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;E é verdade. Segundo a &lt;a href=&quot;https://thephp.foundation/blog/2026/10/21/todays-php-security-release-and-how-were-strengthening-php-security/&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;PHP Foundation&lt;/a&gt;, os primeiros sinais do problema apareceram numa auditoria de 2024, mas a correção travou por meses. Só virou prioridade máxima em agosto de 2026, quando a Calif e a OpenAI reportaram a mesma falha, ambas usando IA na pesquisa. A própria Foundation chamou o atraso de &lt;strong&gt;&quot;uma falha estrutural&quot;&lt;/strong&gt;, por falta de recursos e de um processo de decisão lento. Achei muito honesto da parte deles.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;as-duas-falhas&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;As duas falhas&lt;/h2&gt;

&lt;h3&gt;CVE-2026-109618: o OOM que deixa a casa bagunçada&lt;/h3&gt;

&lt;p&gt;Quando o PHP estoura o &lt;code&gt;memory_limit&lt;/code&gt;, ele usa &lt;code&gt;longjmp()&lt;/code&gt; pra abandonar a requisição na hora. O problema é que, em alguns pontos, a memória da requisição ainda &lt;strong&gt;não foi totalmente inicializada&lt;/strong&gt;, e o shutdown depois lê essa memória como se fosse válida.&lt;/p&gt;

&lt;figure class=&quot;viz&quot; role=&quot;img&quot; aria-label=&quot;Fluxo da CVE-2026-109618, do envio da requisição até a execução remota de código&quot;&gt;
&lt;svg viewBox=&quot;0 0 480 384&quot; xmlns=&quot;http://www.w3.org/2000/svg&quot;&gt;
&lt;defs&gt;&lt;marker id=&quot;arr-oom&quot; viewBox=&quot;0 0 10 10&quot; refX=&quot;9&quot; refY=&quot;5&quot; markerWidth=&quot;7&quot; markerHeight=&quot;7&quot; orient=&quot;auto&quot;&gt;&lt;path class=&quot;arrow&quot; d=&quot;M0,0 L10,5 L0,10 z&quot;/&gt;&lt;/marker&gt;&lt;/defs&gt;
&lt;rect class=&quot;box&quot; x=&quot;40&quot; y=&quot;10&quot; width=&quot;400&quot; height=&quot;40&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;240&quot; y=&quot;35&quot; text-anchor=&quot;middle&quot;&gt;Atacante envia uma requisição multipart&lt;/text&gt;
&lt;line class=&quot;line&quot; x1=&quot;240&quot; y1=&quot;50&quot; x2=&quot;240&quot; y2=&quot;70&quot; marker-end=&quot;url(#arr-oom)&quot;/&gt;
&lt;rect class=&quot;box&quot; x=&quot;40&quot; y=&quot;72&quot; width=&quot;400&quot; height=&quot;40&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;240&quot; y=&quot;97&quot; text-anchor=&quot;middle&quot;&gt;PHP monta $_POST e $_FILES (memória pela metade)&lt;/text&gt;
&lt;line class=&quot;line&quot; x1=&quot;240&quot; y1=&quot;112&quot; x2=&quot;240&quot; y2=&quot;132&quot; marker-end=&quot;url(#arr-oom)&quot;/&gt;
&lt;rect class=&quot;box&quot; x=&quot;40&quot; y=&quot;134&quot; width=&quot;400&quot; height=&quot;40&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;240&quot; y=&quot;159&quot; text-anchor=&quot;middle&quot;&gt;Cabeçalhos e campos aninhados estouram o memory_limit&lt;/text&gt;
&lt;line class=&quot;line&quot; x1=&quot;240&quot; y1=&quot;174&quot; x2=&quot;240&quot; y2=&quot;194&quot; marker-end=&quot;url(#arr-oom)&quot;/&gt;
&lt;rect class=&quot;box-bad&quot; x=&quot;40&quot; y=&quot;196&quot; width=&quot;400&quot; height=&quot;40&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;240&quot; y=&quot;221&quot; text-anchor=&quot;middle&quot;&gt;longjmp(): sai na hora, sem desfazer o que estava pela metade&lt;/text&gt;
&lt;line class=&quot;line&quot; x1=&quot;240&quot; y1=&quot;236&quot; x2=&quot;240&quot; y2=&quot;256&quot; marker-end=&quot;url(#arr-oom)&quot;/&gt;
&lt;rect class=&quot;box&quot; x=&quot;40&quot; y=&quot;258&quot; width=&quot;400&quot; height=&quot;40&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;240&quot; y=&quot;283&quot; text-anchor=&quot;middle&quot;&gt;mod_php executa o shutdown mesmo com a falha&lt;/text&gt;
&lt;line class=&quot;line&quot; x1=&quot;240&quot; y1=&quot;298&quot; x2=&quot;240&quot; y2=&quot;318&quot; marker-end=&quot;url(#arr-oom)&quot;/&gt;
&lt;rect class=&quot;box-bad&quot; x=&quot;40&quot; y=&quot;320&quot; width=&quot;400&quot; height=&quot;40&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t-b&quot; x=&quot;240&quot; y=&quot;345&quot; text-anchor=&quot;middle&quot;&gt;Shutdown lê memória inválida: execução de código&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;240&quot; y=&quot;378&quot; text-anchor=&quot;middle&quot;&gt;Tudo isso acontece antes de qualquer linha da sua aplicação rodar&lt;/text&gt;
&lt;/svg&gt;
&lt;figcaption&gt;CVE-2026-109618: o OOM interrompe o PHP no meio da inicialização.&lt;/figcaption&gt;
&lt;/figure&gt;

&lt;p&gt;No Apache com mod_php, isso acontece durante o parsing do corpo da requisição. Ou seja, não importa se o seu código é seguro: basta ter PHP respondendo HTTP. Detalhes no advisory &lt;a href=&quot;https://github.com/php/php-src/security/advisories/GHSA-w8hw-w9fx-j79w&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;GHSA-w8hw-w9fx-j79w&lt;/a&gt;.&lt;/p&gt;

&lt;h3&gt;CVE-2026-109619: o lixo que fica pra próxima requisição&lt;/h3&gt;

&lt;p&gt;Os workers do PHP atendem várias requisições no mesmo processo. Se um erro fatal ou um OOM interrompe uma requisição, alguns ponteiros globais não são zerados. A memória é liberada, mas a &lt;strong&gt;próxima requisição no mesmo worker&lt;/strong&gt; usa esse ponteiro velho. Um &lt;em&gt;use after free&lt;/em&gt; clássico.&lt;/p&gt;

&lt;figure class=&quot;viz&quot; role=&quot;img&quot; aria-label=&quot;Fluxo da CVE-2026-109619 entre duas requisições no mesmo worker&quot;&gt;
&lt;svg viewBox=&quot;0 0 480 330&quot; xmlns=&quot;http://www.w3.org/2000/svg&quot;&gt;
&lt;defs&gt;&lt;marker id=&quot;arr-uaf&quot; viewBox=&quot;0 0 10 10&quot; refX=&quot;9&quot; refY=&quot;5&quot; markerWidth=&quot;7&quot; markerHeight=&quot;7&quot; orient=&quot;auto&quot;&gt;&lt;path class=&quot;arrow&quot; d=&quot;M0,0 L10,5 L0,10 z&quot;/&gt;&lt;/marker&gt;&lt;/defs&gt;
&lt;rect class=&quot;box&quot; x=&quot;6&quot; y=&quot;6&quot; width=&quot;468&quot; height=&quot;318&quot; rx=&quot;10&quot; fill-opacity=&quot;0&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;20&quot; y=&quot;26&quot;&gt;Mesmo worker do PHP (processo reaproveitado)&lt;/text&gt;
&lt;text class=&quot;t-b&quot; x=&quot;125&quot; y=&quot;54&quot; text-anchor=&quot;middle&quot;&gt;Requisição A&lt;/text&gt;
&lt;text class=&quot;t-b&quot; x=&quot;355&quot; y=&quot;54&quot; text-anchor=&quot;middle&quot;&gt;Requisição B&lt;/text&gt;
&lt;rect class=&quot;box&quot; x=&quot;30&quot; y=&quot;66&quot; width=&quot;190&quot; height=&quot;44&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;125&quot; y=&quot;85&quot; text-anchor=&quot;middle&quot;&gt;Guarda um ponteiro&lt;/text&gt;
&lt;text class=&quot;t&quot; x=&quot;125&quot; y=&quot;101&quot; text-anchor=&quot;middle&quot;&gt;em estado global&lt;/text&gt;
&lt;line class=&quot;line&quot; x1=&quot;125&quot; y1=&quot;110&quot; x2=&quot;125&quot; y2=&quot;128&quot; marker-end=&quot;url(#arr-uaf)&quot;/&gt;
&lt;rect class=&quot;box-bad&quot; x=&quot;30&quot; y=&quot;130&quot; width=&quot;190&quot; height=&quot;44&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;125&quot; y=&quot;149&quot; text-anchor=&quot;middle&quot;&gt;Erro fatal ou OOM:&lt;/text&gt;
&lt;text class=&quot;t&quot; x=&quot;125&quot; y=&quot;165&quot; text-anchor=&quot;middle&quot;&gt;o reset é pulado&lt;/text&gt;
&lt;line class=&quot;line&quot; x1=&quot;125&quot; y1=&quot;174&quot; x2=&quot;125&quot; y2=&quot;192&quot; marker-end=&quot;url(#arr-uaf)&quot;/&gt;
&lt;rect class=&quot;box&quot; x=&quot;30&quot; y=&quot;194&quot; width=&quot;190&quot; height=&quot;44&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;125&quot; y=&quot;213&quot; text-anchor=&quot;middle&quot;&gt;Memória da requisição&lt;/text&gt;
&lt;text class=&quot;t&quot; x=&quot;125&quot; y=&quot;229&quot; text-anchor=&quot;middle&quot;&gt;é liberada&lt;/text&gt;
&lt;rect class=&quot;box&quot; x=&quot;260&quot; y=&quot;66&quot; width=&quot;190&quot; height=&quot;44&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;355&quot; y=&quot;85&quot; text-anchor=&quot;middle&quot;&gt;INI ou upload progress&lt;/text&gt;
&lt;text class=&quot;t&quot; x=&quot;355&quot; y=&quot;101&quot; text-anchor=&quot;middle&quot;&gt;antes da inicialização&lt;/text&gt;
&lt;line class=&quot;line&quot; x1=&quot;355&quot; y1=&quot;110&quot; x2=&quot;355&quot; y2=&quot;128&quot; marker-end=&quot;url(#arr-uaf)&quot;/&gt;
&lt;rect class=&quot;box-bad&quot; x=&quot;260&quot; y=&quot;130&quot; width=&quot;190&quot; height=&quot;44&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;355&quot; y=&quot;149&quot; text-anchor=&quot;middle&quot;&gt;Usa o ponteiro velho&lt;/text&gt;
&lt;text class=&quot;t&quot; x=&quot;355&quot; y=&quot;165&quot; text-anchor=&quot;middle&quot;&gt;(use after free)&lt;/text&gt;
&lt;line class=&quot;line&quot; x1=&quot;355&quot; y1=&quot;174&quot; x2=&quot;355&quot; y2=&quot;192&quot; marker-end=&quot;url(#arr-uaf)&quot;/&gt;
&lt;rect class=&quot;box-bad&quot; x=&quot;260&quot; y=&quot;194&quot; width=&quot;190&quot; height=&quot;44&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t-b&quot; x=&quot;355&quot; y=&quot;213&quot; text-anchor=&quot;middle&quot;&gt;Heap manipulado:&lt;/text&gt;
&lt;text class=&quot;t-b&quot; x=&quot;355&quot; y=&quot;229&quot; text-anchor=&quot;middle&quot;&gt;execução de código&lt;/text&gt;
&lt;rect class=&quot;box&quot; x=&quot;130&quot; y=&quot;266&quot; width=&quot;220&quot; height=&quot;40&quot; rx=&quot;6&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;240&quot; y=&quot;291&quot; text-anchor=&quot;middle&quot;&gt;Ponteiro global para memória livre&lt;/text&gt;
&lt;path class=&quot;line&quot; d=&quot;M125,238 L125,286 L128,286&quot; marker-end=&quot;url(#arr-uaf)&quot;/&gt;
&lt;path class=&quot;line&quot; d=&quot;M350,286 L464,286 L464,152 L454,152&quot; marker-end=&quot;url(#arr-uaf)&quot;/&gt;
&lt;/svg&gt;
&lt;figcaption&gt;CVE-2026-109619: a requisição A deixa o lixo, a requisição B consome.&lt;/figcaption&gt;
&lt;/figure&gt;

&lt;p&gt;Os casos confirmados envolvem o &lt;code&gt;fatal_error_backtraces&lt;/code&gt; do PHP 8.5 e o &lt;em&gt;session upload progress&lt;/em&gt;, que vinha habilitado por padrão (a partir das versões de 19/11, ele vem desligado). E um detalhe importante: usar &lt;code&gt;@&lt;/code&gt; ou desligar o &lt;code&gt;display_errors&lt;/code&gt; &lt;strong&gt;não protege&lt;/strong&gt;. Detalhes no advisory &lt;a href=&quot;https://github.com/php/php-src/security/advisories/GHSA-6wmf-4rv5-p3rp&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;GHSA-6wmf-4rv5-p3rp&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;quem-esta-em-risco&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Quem está em risco e qual a gravidade?&lt;/h2&gt;

&lt;p&gt;Segundo o PHP, &lt;strong&gt;toda instalação que atende requisições web&lt;/strong&gt;. O risco muda conforme a SAPI (a forma como o PHP roda no servidor) e é maior no mod_php:&lt;/p&gt;

&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
  &lt;th&gt;SAPI&lt;/th&gt;
  &lt;th&gt;CVE-2026-109618 (OOM)&lt;/th&gt;
  &lt;th&gt;CVE-2026-109619 (estado global)&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
  &lt;td&gt;Apache mod_php&lt;/td&gt;
  &lt;td&gt;&lt;strong&gt;Exploit confirmado&lt;/strong&gt;, sem depender da aplicação&lt;/td&gt;
  &lt;td&gt;&lt;strong&gt;Exploit confirmado&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;PHP-FPM&lt;/td&gt;
  &lt;td&gt;&lt;strong&gt;RCE confirmada&lt;/strong&gt;, via código da aplicação&lt;/td&gt;
  &lt;td&gt;&lt;strong&gt;RCE validada&lt;/strong&gt; via upload progress&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;FrankenPHP, LiteSpeed, php-cgi&lt;/td&gt;
  &lt;td&gt;Provável ou no escopo do aviso&lt;/td&gt;
  &lt;td&gt;Condicional&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;

&lt;p&gt;As duas receberam &lt;strong&gt;CVSS v4.0 9.2&lt;/strong&gt;:&lt;/p&gt;

&lt;figure class=&quot;viz&quot; role=&quot;img&quot; aria-label=&quot;Escala CVSS de 0 a 10 comparando a nota oficial 9,2 com a nota 10 que circulou no vazamento&quot;&gt;
&lt;svg viewBox=&quot;0 0 480 150&quot; xmlns=&quot;http://www.w3.org/2000/svg&quot;&gt;
&lt;rect class=&quot;crit&quot; x=&quot;420&quot; y=&quot;18&quot; width=&quot;30&quot; height=&quot;84&quot; opacity=&quot;0.12&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;435&quot; y=&quot;12&quot; text-anchor=&quot;middle&quot;&gt;crítico&lt;/text&gt;
&lt;line class=&quot;grid&quot; x1=&quot;150&quot; y1=&quot;18&quot; x2=&quot;150&quot; y2=&quot;102&quot;/&gt;
&lt;line class=&quot;grid&quot; x1=&quot;270&quot; y1=&quot;18&quot; x2=&quot;270&quot; y2=&quot;102&quot;/&gt;
&lt;line class=&quot;grid&quot; x1=&quot;360&quot; y1=&quot;18&quot; x2=&quot;360&quot; y2=&quot;102&quot;/&gt;
&lt;line class=&quot;grid&quot; x1=&quot;420&quot; y1=&quot;18&quot; x2=&quot;420&quot; y2=&quot;102&quot;/&gt;
&lt;line class=&quot;grid&quot; x1=&quot;450&quot; y1=&quot;18&quot; x2=&quot;450&quot; y2=&quot;102&quot;/&gt;
&lt;rect class=&quot;s1&quot; x=&quot;150&quot; y=&quot;30&quot; width=&quot;276&quot; height=&quot;24&quot; rx=&quot;3&quot; data-hover&gt;&lt;title&gt;Nota oficial do PHP: CVSS v4.0 9,2&lt;/title&gt;&lt;/rect&gt;
&lt;text class=&quot;t&quot; x=&quot;140&quot; y=&quot;47&quot; text-anchor=&quot;end&quot;&gt;Oficial (PHP)&lt;/text&gt;
&lt;text class=&quot;t-b&quot; x=&quot;242&quot; y=&quot;47&quot; style=&quot;fill:#fff&quot;&gt;9,2&lt;/text&gt;
&lt;rect class=&quot;s2&quot; x=&quot;150&quot; y=&quot;66&quot; width=&quot;300&quot; height=&quot;24&quot; rx=&quot;3&quot; data-hover&gt;&lt;title&gt;O que circulou no vazamento: CVSS 10&lt;/title&gt;&lt;/rect&gt;
&lt;text class=&quot;t&quot; x=&quot;140&quot; y=&quot;83&quot; text-anchor=&quot;end&quot;&gt;Vazamento&lt;/text&gt;
&lt;text class=&quot;t-b&quot; x=&quot;242&quot; y=&quot;83&quot; style=&quot;fill:#fff&quot;&gt;10&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;150&quot; y=&quot;120&quot; text-anchor=&quot;middle&quot;&gt;0&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;270&quot; y=&quot;120&quot; text-anchor=&quot;middle&quot;&gt;4&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;360&quot; y=&quot;120&quot; text-anchor=&quot;middle&quot;&gt;7&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;420&quot; y=&quot;120&quot; text-anchor=&quot;middle&quot;&gt;9&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;450&quot; y=&quot;120&quot; text-anchor=&quot;middle&quot;&gt;10&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;210&quot; y=&quot;140&quot; text-anchor=&quot;middle&quot;&gt;baixa&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;315&quot; y=&quot;140&quot; text-anchor=&quot;middle&quot;&gt;média&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;390&quot; y=&quot;140&quot; text-anchor=&quot;middle&quot;&gt;alta&lt;/text&gt;
&lt;/svg&gt;
&lt;figcaption&gt;Não é 10, mas continua no topo da escala.&lt;/figcaption&gt;
&lt;/figure&gt;

&lt;p&gt;Não é 10 porque explorar é complexo (falo disso mais abaixo). Mas, na prática, eu não daria importância pra essa diferença: é RCE sem autenticação, numa das linguagens mais usadas da web. E o ataque ainda vaza memória do servidor, o que pode expor sessões e senhas mesmo quando não chega a executar código. A exploração já foi confirmada, e a CISA colocou as duas no catálogo de vulnerabilidades exploradas ativamente.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;fake-news&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Fake news e exageros&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;&quot;Vazaram os detalhes técnicos.&quot;&lt;/strong&gt; Falso. Vazaram só os IDs das CVEs. O que ajudou atacantes foi o vídeo publicado por engano.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&quot;A falha derrubou a internet.&quot;&lt;/strong&gt; Exagero. Os sites foram tirados do ar de propósito, por precaução, e não por ataque.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&quot;Afeta desde o PHP 5.&quot;&lt;/strong&gt; Verdadeiro, segundo a watchTowr. Mas do 7.3 pra baixo não existe correção do PHP, só de distros e fornecedores de LTS.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&quot;Tem PR no GitHub corrigindo, é só aplicar.&quot;&lt;/strong&gt; Cuidado. Os PRs de terceiros foram todos fechados sem merge. Não aplique patch de origem desconhecida em produção.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&quot;Saiu outra RCE crítica sem correção.&quot;&lt;/strong&gt; Exagero. A CVE-2026-115560 exige uma configuração bem incomum, e &lt;a href=&quot;https://www.php.net/archive/2026.php#2026-10-23-1&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;o PHP vai corrigir no ciclo normal&lt;/a&gt;. Desligar o &lt;code&gt;session.upload_progress.enabled&lt;/code&gt; já resolve. Ela foi corrigida &lt;a href=&quot;/blog/php-falhas-seguranca-novembro-2026&quot;&gt;na release de 19/11&lt;/a&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a id=&quot;a-correcao&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Como o PHP corrigiu&lt;/h2&gt;

&lt;p&gt;Fui atrás do PR da correção e descobri que &lt;strong&gt;não existe PR público&lt;/strong&gt;. Correções de segurança no PHP são feitas em privado e entram direto como commit no dia da release. Neste caso, foi o commit &lt;a href=&quot;https://github.com/php/php-src/commit/3584a98bda0f2c0d367255b046798b0d3a221a19&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;3584a98&lt;/a&gt;, &lt;strong&gt;&quot;Avoid state corruption via bailout&quot;&lt;/strong&gt;, que fecha as duas CVEs.&lt;/p&gt;

&lt;p&gt;E não é pequeno: são &lt;strong&gt;mais de 300 arquivos&lt;/strong&gt; e cerca de &lt;strong&gt;10,7 mil linhas adicionadas&lt;/strong&gt;, boa parte testes simulando OOM em praticamente toda a biblioteca padrão. Na prática:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;o &lt;code&gt;longjmp()&lt;/code&gt; no OOM foi removido&lt;/strong&gt;, e o PHP agora interrompe a execução num ponto seguro da VM;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;os estados globais passaram a ser resetados&lt;/strong&gt; antes da memória da requisição ser liberada.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;A Foundation também anunciou mais gente no time de segurança, novas auditorias e decisões por maioria em vez de consenso, pra isso não travar de novo. E fez um pedido que eu reforço: se a sua empresa depende de PHP, vale olhar o &lt;a href=&quot;https://thephp.foundation/sponsor/&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;programa de sponsors&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;como-saber-se-estou-vulneravel&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Como saber se estou vulnerável?&lt;/h2&gt;

&lt;p&gt;Você está protegido se estiver em uma destas versões ou superior:&lt;/p&gt;

&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
  &lt;th&gt;Branch&lt;/th&gt;
  &lt;th&gt;Versão corrigida&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
  &lt;td&gt;8.5&lt;/td&gt;
  &lt;td&gt;8.5.12&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;8.4&lt;/td&gt;
  &lt;td&gt;8.4.27&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;8.3&lt;/td&gt;
  &lt;td&gt;8.3.36&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;8.2&lt;/td&gt;
  &lt;td&gt;8.2.35&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;7.4, 8.0 e 8.1&lt;/td&gt;
  &lt;td&gt;Sem release, só branches de backport pra compilar: &lt;a href=&quot;https://github.com/php/php-src/tree/PHP-7.4-CVE-2026-109618-109619&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;7.4&lt;/a&gt;, &lt;a href=&quot;https://github.com/php/php-src/tree/PHP-8.0-CVE-2026-109618-109619&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;8.0&lt;/a&gt; e &lt;a href=&quot;https://github.com/php/php-src/tree/PHP-8.1-CVE-2026-109618-109619&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;8.1&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
  &lt;td&gt;7.3 ou anterior&lt;/td&gt;
  &lt;td&gt;Sem correção do PHP, só via distro ou LTS&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;

&lt;p&gt;Se você usa Debian ou Ubuntu com os pacotes do &lt;strong&gt;Ondřej Surý&lt;/strong&gt; (&lt;code&gt;ppa:ondrej/php&lt;/code&gt; ou &lt;code&gt;deb.sury.org&lt;/code&gt;), ele já portou a correção pro 5.6, 7.4, 8.0 e 8.1, de graça. Pra 7.0 a 7.3, existem opções pagas, como Freexian, TuxCare e Ubuntu Pro (&lt;a href=&quot;https://sansec.io/research/php2shell&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;a Sansec reuniu a lista&lt;/a&gt;). Já a imagem Docker oficial &lt;code&gt;php&lt;/code&gt; não recebe correção pra 8.1 ou anterior.&lt;/p&gt;

&lt;p&gt;Pra conferir, crie um arquivo temporário no servidor, acesse pelo navegador (assim ele roda na mesma SAPI do site) e &lt;strong&gt;apague logo depois&lt;/strong&gt;:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;&amp;lt;?php
$fixed = [&#039;8.6&#039; =&amp;gt; &#039;8.6.0RC4&#039;, &#039;8.5&#039; =&amp;gt; &#039;8.5.12&#039;, &#039;8.4&#039; =&amp;gt; &#039;8.4.27&#039;, &#039;8.3&#039; =&amp;gt; &#039;8.3.36&#039;, &#039;8.2&#039; =&amp;gt; &#039;8.2.35&#039;];
$branch = PHP_MAJOR_VERSION . &#039;.&#039; . PHP_MINOR_VERSION;

echo &#039;Versão: &#039;, PHP_VERSION, &#039; | SAPI: &#039;, PHP_SAPI, PHP_EOL;

if (!isset($fixed[$branch])) {
    echo &quot;Branch sem suporte: não existe release oficial com a correção&quot;, PHP_EOL;
} elseif (version_compare(PHP_VERSION, $fixed[$branch], &#039;&amp;lt;&#039;)) {
    echo &quot;VULNERÁVEL: atualize para {$fixed[$branch]} ou superior&quot;, PHP_EOL;
} else {
    echo &quot;Versão com a correção&quot;, PHP_EOL;
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Se &lt;code&gt;SAPI&lt;/code&gt; vier como &lt;code&gt;apache2handler&lt;/code&gt;, você está no mod_php, o cenário mais exposto. Pra varrer muitos sites de uma vez, a ProjectDiscovery publicou um &lt;a href=&quot;https://projectdiscovery.io/research/php2shell&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;template do Nuclei&lt;/a&gt; que só lê a versão no header, sem explorar nada.&lt;/p&gt;

&lt;p&gt;Alguns cuidados:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;pacotes de distro&lt;/strong&gt; (Debian, Ubuntu, RHEL) fazem backport sem mudar o número da versão. Consulte o aviso de segurança da sua distribuição;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;imagens Docker não se atualizam sozinhas&lt;/strong&gt;: faça &lt;code&gt;docker pull&lt;/code&gt;, rebuild e deploy;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;reinicie todos os workers&lt;/strong&gt; depois de atualizar. Processo velho continua rodando o binário antigo;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;evite os &quot;testes&quot; que circulam no GitHub&lt;/strong&gt; fazendo probe ativo. Muitos derrubam o worker de propósito. A versão e a SAPI já respondem se você está vulnerável.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;E se eu já fui atacado?&lt;/h3&gt;

&lt;p&gt;Procure nos logs o Apache ou o PHP-FPM abrindo &lt;code&gt;sh&lt;/code&gt;, &lt;code&gt;curl&lt;/code&gt; ou &lt;code&gt;wget&lt;/code&gt;, User-Agent com &quot;php2shell&quot; ou o número da CVE e picos de &lt;code&gt;Allowed memory size exhausted&lt;/code&gt;. Encontrou algo? Trate como incidente, não só como atualização.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;nao-consigo-atualizar-agora&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Não consigo atualizar agora, e aí?&lt;/h2&gt;

&lt;p&gt;O PHP publicou mitigações temporárias. Elas &lt;strong&gt;reduzem&lt;/strong&gt; o risco, mas não resolvem:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-ini&quot;&gt;; php.ini, pool do FPM ou config do servidor
session.upload_progress.enabled = 0
memory_limit = -1          ; via php_admin_value
post_max_size = 8M         ; 32M se precisar de upload
upload_max_filesize = 2M
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;No PHP 8.5, defina também &lt;code&gt;fatal_error_backtraces=0&lt;/code&gt;, limite o tamanho das requisições no Nginx ou Apache e reinicie todos os workers. Sim, &lt;code&gt;memory_limit = -1&lt;/code&gt; parece estranho, mas o exploit depende justamente de estourar esse limite de forma previsível. É paliativo, não solução.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;o-php-vai-morrer&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Então o PHP acabou? Claro que não&lt;/h2&gt;

&lt;p&gt;Com tanta manchete, já apareceu gente dizendo que &quot;é hora de largar o PHP&quot;. Calma.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Não é uma falha fácil de explorar.&lt;/strong&gt; O exploit depende de layout de memória, do build e da quantidade de workers. A primeira RCE confirmada na internet foi num ambiente propositalmente favorável, com um único worker, e os PoCs que circularam antes da correção não funcionavam. Isso não é motivo pra relaxar, mas também não é um &quot;qualquer um invade qualquer site PHP com um comando&quot;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;E não foi só o PHP.&lt;/strong&gt; Na mesma semana, o Node.js corrigiu o &lt;a href=&quot;https://www.akamai.com/blog/security-research/inside-node2shell-closer-look-cve-2026-111497&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;Node2Shell&lt;/a&gt; (CVE-2026-111497), uma falha no decodificador Brotli que também permite execução remota de código. Express 5, Koa e o próprio &lt;code&gt;fetch()&lt;/code&gt; descomprimem Brotli por padrão. E como o problema está na biblioteca do Google, &lt;a href=&quot;https://thehackernews.com/2026/10/brotli-decoder-flaw-behind-nodejs-rce.html&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;ele também atingiu Bun, Python, .NET e outras ferramentas&lt;/a&gt;. Inclusive o próprio PHP no Windows, que ganhou builds novos por causa dela.&lt;/p&gt;

&lt;p&gt;O que está acontecendo é maior que uma linguagem: a IA mudou o ritmo da segurança, pros dois lados. Ela está encontrando falhas antigas em todo o ecossistema (o PHP publicou 15 CVEs desde julho, e a falha do Node.js também foi reportada por uma ferramenta de IA) e acelerou a resposta: a Foundation passou a usar IA pra validar reports e exploits e agrupar os que têm a mesma causa raiz. Mas a correção continua sendo trabalho humano, nas palavras deles, &lt;em&gt;&quot;uma pessoa toma cada decisão e trabalha em cada patch&quot;&lt;/em&gt;. E a mesma IA gerou mais de 100 reports inválidos ou duplicados e está nas mãos de quem ataca.&lt;/p&gt;

&lt;p&gt;Linguagem madura não é a que nunca tem falha, é a que corrige rápido e com transparência quando elas aparecem.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;manter-atualizado&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Manter atualizado não é opcional&lt;/h2&gt;

&lt;p&gt;Pra mim, essa é a principal lição. Quem estava numa branch suportada só precisou subir um patch. Quem está no 8.1 ou anterior ficou sem release: no máximo uma branch de backport pra compilar na mão ou o pacote de um mantenedor, e do 7.3 pra baixo, nem isso vindo do PHP. E não é pouca gente: a Mallory contou cerca de &lt;strong&gt;884 mil servidores expostos&lt;/strong&gt; nessa situação na véspera da correção.&lt;/p&gt;

&lt;figure class=&quot;viz&quot; role=&quot;img&quot; aria-label=&quot;Ciclo de suporte das versões 8.2 a 8.5 do PHP com a data de hoje marcada&quot;&gt;
&lt;svg viewBox=&quot;0 0 480 215&quot; xmlns=&quot;http://www.w3.org/2000/svg&quot;&gt;
&lt;line class=&quot;grid&quot; x1=&quot;86.7&quot; y1=&quot;22&quot; x2=&quot;86.7&quot; y2=&quot;162&quot;/&gt;
&lt;line class=&quot;grid&quot; x1=&quot;140&quot; y1=&quot;22&quot; x2=&quot;140&quot; y2=&quot;162&quot;/&gt;
&lt;line class=&quot;grid&quot; x1=&quot;193.3&quot; y1=&quot;22&quot; x2=&quot;193.3&quot; y2=&quot;162&quot;/&gt;
&lt;line class=&quot;grid&quot; x1=&quot;246.7&quot; y1=&quot;22&quot; x2=&quot;246.7&quot; y2=&quot;162&quot;/&gt;
&lt;line class=&quot;grid&quot; x1=&quot;300&quot; y1=&quot;22&quot; x2=&quot;300&quot; y2=&quot;162&quot;/&gt;
&lt;line class=&quot;grid&quot; x1=&quot;353.3&quot; y1=&quot;22&quot; x2=&quot;353.3&quot; y2=&quot;162&quot;/&gt;
&lt;line class=&quot;grid&quot; x1=&quot;406.7&quot; y1=&quot;22&quot; x2=&quot;406.7&quot; y2=&quot;162&quot;/&gt;
&lt;line class=&quot;grid&quot; x1=&quot;460&quot; y1=&quot;22&quot; x2=&quot;460&quot; y2=&quot;162&quot;/&gt;
&lt;text class=&quot;t-b&quot; x=&quot;50&quot; y=&quot;45&quot; text-anchor=&quot;end&quot;&gt;8.2&lt;/text&gt;
&lt;rect class=&quot;s1&quot; x=&quot;82.9&quot; y=&quot;30&quot; width=&quot;110.4&quot; height=&quot;22&quot; rx=&quot;3&quot; data-hover&gt;&lt;title&gt;PHP 8.2: suporte ativo de dez/2022 a dez/2024&lt;/title&gt;&lt;/rect&gt;
&lt;rect class=&quot;s2&quot; x=&quot;195.3&quot; y=&quot;30&quot; width=&quot;104.7&quot; height=&quot;22&quot; rx=&quot;3&quot; data-hover&gt;&lt;title&gt;PHP 8.2: só segurança até 31/12/2026&lt;/title&gt;&lt;/rect&gt;
&lt;text class=&quot;t-b&quot; x=&quot;50&quot; y=&quot;80&quot; text-anchor=&quot;end&quot;&gt;8.3&lt;/text&gt;
&lt;rect class=&quot;s1&quot; x=&quot;134.1&quot; y=&quot;65&quot; width=&quot;112.6&quot; height=&quot;22&quot; rx=&quot;3&quot; data-hover&gt;&lt;title&gt;PHP 8.3: suporte ativo de nov/2023 a dez/2025&lt;/title&gt;&lt;/rect&gt;
&lt;rect class=&quot;s2&quot; x=&quot;248.7&quot; y=&quot;65&quot; width=&quot;104.6&quot; height=&quot;22&quot; rx=&quot;3&quot; data-hover&gt;&lt;title&gt;PHP 8.3: só segurança até 31/12/2027&lt;/title&gt;&lt;/rect&gt;
&lt;text class=&quot;t-b&quot; x=&quot;50&quot; y=&quot;115&quot; text-anchor=&quot;end&quot;&gt;8.4&lt;/text&gt;
&lt;rect class=&quot;s1&quot; x=&quot;187.5&quot; y=&quot;100&quot; width=&quot;112.5&quot; height=&quot;22&quot; rx=&quot;3&quot; data-hover&gt;&lt;title&gt;PHP 8.4: suporte ativo de nov/2024 a dez/2026&lt;/title&gt;&lt;/rect&gt;
&lt;rect class=&quot;s2&quot; x=&quot;302&quot; y=&quot;100&quot; width=&quot;104.7&quot; height=&quot;22&quot; rx=&quot;3&quot; data-hover&gt;&lt;title&gt;PHP 8.4: só segurança até 31/12/2028&lt;/title&gt;&lt;/rect&gt;
&lt;text class=&quot;t-b&quot; x=&quot;50&quot; y=&quot;150&quot; text-anchor=&quot;end&quot;&gt;8.5&lt;/text&gt;
&lt;rect class=&quot;s1&quot; x=&quot;240.8&quot; y=&quot;135&quot; width=&quot;112.5&quot; height=&quot;22&quot; rx=&quot;3&quot; data-hover&gt;&lt;title&gt;PHP 8.5: suporte ativo de nov/2025 a dez/2027&lt;/title&gt;&lt;/rect&gt;
&lt;rect class=&quot;s2&quot; x=&quot;355.3&quot; y=&quot;135&quot; width=&quot;104.7&quot; height=&quot;22&quot; rx=&quot;3&quot; data-hover&gt;&lt;title&gt;PHP 8.5: só segurança até 31/12/2029&lt;/title&gt;&lt;/rect&gt;
&lt;line class=&quot;crit-line&quot; x1=&quot;290.4&quot; y1=&quot;20&quot; x2=&quot;290.4&quot; y2=&quot;162&quot;/&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;290.4&quot; y=&quot;14&quot; text-anchor=&quot;middle&quot;&gt;hoje&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;86.7&quot; y=&quot;178&quot; text-anchor=&quot;middle&quot;&gt;2023&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;140&quot; y=&quot;178&quot; text-anchor=&quot;middle&quot;&gt;2024&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;193.3&quot; y=&quot;178&quot; text-anchor=&quot;middle&quot;&gt;2025&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;246.7&quot; y=&quot;178&quot; text-anchor=&quot;middle&quot;&gt;2026&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;300&quot; y=&quot;178&quot; text-anchor=&quot;middle&quot;&gt;2027&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;353.3&quot; y=&quot;178&quot; text-anchor=&quot;middle&quot;&gt;2028&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;406.7&quot; y=&quot;178&quot; text-anchor=&quot;middle&quot;&gt;2029&lt;/text&gt;
&lt;text class=&quot;t-sm&quot; x=&quot;460&quot; y=&quot;178&quot; text-anchor=&quot;end&quot;&gt;2030&lt;/text&gt;
&lt;rect class=&quot;s1&quot; x=&quot;90&quot; y=&quot;194&quot; width=&quot;12&quot; height=&quot;12&quot; rx=&quot;2&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;108&quot; y=&quot;205&quot;&gt;Suporte ativo&lt;/text&gt;
&lt;rect class=&quot;s2&quot; x=&quot;230&quot; y=&quot;194&quot; width=&quot;12&quot; height=&quot;12&quot; rx=&quot;2&quot;/&gt;
&lt;text class=&quot;t&quot; x=&quot;248&quot; y=&quot;205&quot;&gt;Só correções de segurança&lt;/text&gt;
&lt;/svg&gt;
&lt;figcaption&gt;Fonte: php.net/supported-versions. O PHP 8.2 sai de suporte em 31/12/2026.&lt;/figcaption&gt;
&lt;/figure&gt;

&lt;p&gt;O que vale pra qualquer time:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;esteja numa branch suportada.&lt;/strong&gt; Se ainda está no 8.2, comece a migração agora;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;deixe o patch barato.&lt;/strong&gt; Imagem versionada, testes automatizados e deploy simples transformam um patch de emergência em rotina;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;saiba o que roda em produção.&lt;/strong&gt; Na hora do incidente, ninguém quer descobrir um servidor esquecido rodando mod_php.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a id=&quot;conclusao&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Conclusão&lt;/h2&gt;

&lt;p&gt;O PHP2Shell foi sério: RCE sem autenticação, exploit confirmado e sites de governo fora do ar. E não dá pra ignorar que o problema era conhecido desde 2024.&lt;/p&gt;

&lt;p&gt;Ao mesmo tempo, gostei da forma como a Foundation lidou com isso: assumiu o erro publicamente, explicou o que vai mudar e entregou uma correção que mexe de verdade na forma como o PHP lida com falta de memória. Isso é sinal de um projeto maduro.&lt;/p&gt;

&lt;p&gt;A lição é a de sempre, mas continua valendo: &lt;strong&gt;atualize&lt;/strong&gt;, e organize o seu ambiente pra que atualizar seja fácil da próxima vez.&lt;/p&gt;

&lt;p&gt;Até a próxima e abraços! 🐘&lt;/p&gt;

&lt;p&gt;Referências:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://thephp.foundation/blog/2026/10/21/todays-php-security-release-and-how-were-strengthening-php-security/&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;The PHP Foundation: Today&#039;s PHP security release and how we&#039;re strengthening PHP security&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.php.net/archive/2026.php#2026-10-21-5&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;PHP.net: Security advisory, critical remote code execution vulnerabilities&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.php.net/archive/2026.php#2026-10-23-1&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;PHP.net: Informational advisory, session upload progress&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://github.com/php/php-src/commit/3584a98bda0f2c0d367255b046798b0d3a221a19&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;Commit da correção no php-src&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://watchtowr.com/intelligence/php-cve-2026-109618-faq/&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;watchTowr: PHP2Shell FAQ&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.cisa.gov/news-events/alerts/2026/10/21/critical-vulnerabilities-php-require-immediate-patching&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;CISA: Critical vulnerabilities in PHP require immediate patching&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://g1.globo.com/tecnologia/noticia/2026/10/22/o-que-e-php-e-a-falha-grave-de-seguranca-detectada-por-ia-que-tirou-sites-do-ar.ghtml&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;g1: O que é PHP e a falha grave de segurança detectada por IA que tirou sites do ar&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://g1.globo.com/tecnologia/ciberseguranca/noticia/2026/10/23/brecha-no-php-que-tirou-sites-do-ar-foi-descoberta-ha-dois-anos-responsavel-cita-falta-de-recursos-para-corrigi-la.ghtml&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;g1: Brecha no PHP que tirou sites do ar foi descoberta há dois anos&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://timesbrasil.com.br/empresas-e-negocios/inteligencia-artificial/seguranca-falha-php-sites-governos-fora-do-ar/&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;Times Brasil: Falha de segurança tira páginas de governos do ar e leva NSA a alertar empresas&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://x.com/FBICyberDiv/status/2112921648252719420&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;FBI Cyber Division: alerta sobre as vulnerabilidades no PHP&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.newsweek.com/fbi-issues-advice-as-security-issue-hits-global-websites-12603155&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;Newsweek: FBI issues advice as security issue hits global websites&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.akamai.com/blog/security-research/inside-node2shell-closer-look-cve-2026-111497&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;Akamai: Inside Node2Shell, a closer look at CVE-2026-111497&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://thehackernews.com/2026/10/brotli-decoder-flaw-behind-nodejs-rce.html&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;The Hacker News: Brotli decoder flaw behind Node.js RCE also affects Bun, Python and other software&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://sansec.io/research/php2shell&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;Sansec: PHP2Shell, correções pra versões sem suporte&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://projectdiscovery.io/research/php2shell&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;ProjectDiscovery: PHP2Shell, finding and patching affected PHP&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content>
        </entry>
            <entry>
            <id>https://www.marcosmarcolin.com.br/blog/typephp-compilador-aot-para-php</id>
            <link type="text/html" rel="alternate" href="https://www.marcosmarcolin.com.br/blog/typephp-compilador-aot-para-php" />
            <title>TypePHP, o compilador que transforma PHP em binário nativo</title>
            <published>2026-08-27T00:00:00+00:00</published>
            <updated>2026-08-27T00:00:00+00:00</updated>
            <author>
                <name>Marcos Marcolin</name>
            </author>
            <summary type="html">O TypePHP, projeto da equipe Swoole, compila PHP para C++ e gera binários nativos. Veja o que isso muda para quem desenvolve em PHP.</summary>
            <content type="html">&lt;p&gt;Recentemente, a equipe do &lt;a href=&quot;https://github.com/swoole&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;Swoole&lt;/a&gt; colocou em open source um projeto que me chamou bastante atenção: o &lt;a href=&quot;https://github.com/swoole/typephp&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;TypePHP&lt;/a&gt;, um compilador &lt;code&gt;AOT&lt;/code&gt; (Ahead-of-Time) para PHP.&lt;/p&gt;

&lt;p&gt;Pra quem não é familiar com o termo, &lt;code&gt;AOT&lt;/code&gt; significa que o código é compilado antes de rodar, virando um binário pronto, ao contrário do PHP tradicional, que interpreta o código (ou compila trechos em tempo real, no caso do JIT) a cada execução.&lt;/p&gt;

&lt;p&gt;A ideia é simples de explicar: você escreve PHP, e ele compila esse código para código nativo, passando por C++ no meio do caminho. Na prática, isso permite gerar executáveis, extensões PHP e bibliotecas compartilhadas.&lt;/p&gt;

&lt;p&gt;E a pergunta que fica é: o que isso muda para quem já desenvolve em PHP?&lt;/p&gt;

&lt;h2&gt;Sumário&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;#php-que-vira-executavel&quot;&gt;PHP que vira executável&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#um-worker-que-fica-rodando&quot;&gt;Um worker que fica rodando&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#e-as-extensoes-php&quot;&gt;E as extensões PHP?&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#onde-isso-realmente-faz-sentido&quot;&gt;Onde isso realmente faz sentido?&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#e-a-performance&quot;&gt;E a performance?&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#o-que-ainda-nao-e&quot;&gt;O que ainda não é&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#para-quem-o-typephp-e-interessante&quot;&gt;Para quem o TypePHP é interessante?&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#vale-a-pena-acompanhar&quot;&gt;Vale a pena acompanhar?&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#em-resumo&quot;&gt;Em resumo&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#conclusao&quot;&gt;Conclusão&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a id=&quot;php-que-vira-executavel&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;PHP que vira executável&lt;/h2&gt;

&lt;p&gt;Estamos acostumados a executar PHP assim:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;php app.php
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Ou, numa aplicação web:&lt;/p&gt;

&lt;pre&gt;&lt;code&gt;HTTP Request
     ↓
   Nginx
     ↓
  PHP-FPM
     ↓
Código PHP
     ↓
 Response
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Com o TypePHP existe outra possibilidade:&lt;/p&gt;

&lt;pre&gt;&lt;code&gt;PHP
 ↓
TypePHP
 ↓
C++
 ↓
compilador nativo
 ↓
executável
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Por exemplo:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;&amp;lt;?php
function calculate(int $n): int
{
    $result = 0;
    for ($i = 0; $i &amp;lt; $n; $i++) {
        $result += $i * $i;
    }
    return $result;
}

echo calculate(1000000);
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Em vez de distribuir o arquivo &lt;code&gt;.php&lt;/code&gt;, a ideia é compilar esse código para um executável que roda direto com &lt;code&gt;./app&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;O TypePHP tem uma CLI própria, &lt;code&gt;tpc&lt;/code&gt;, com diferentes modos de compilação: &lt;code&gt;bin&lt;/code&gt;, &lt;code&gt;ext&lt;/code&gt; e &lt;code&gt;lib&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Isso abre uma possibilidade que a gente não costuma associar ao PHP: distribuir uma aplicação como programa nativo. Imagine uma ferramenta:&lt;/p&gt;

&lt;pre&gt;&lt;code&gt;mytool backup
mytool migrate
mytool analyze
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Em vez de o usuário precisar instalar PHP, Composer, dependências e extensões, você distribui um único executável.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;um-worker-que-fica-rodando&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Um worker que fica rodando&lt;/h2&gt;

&lt;p&gt;Outra possibilidade é criar programas que ficam vivos continuamente. Por exemplo, um worker:&lt;/p&gt;

&lt;pre&gt;&lt;code&gt;RabbitMQ
    ↓
┌──────────────────────┐
│     my-worker         │
│                       │
│  pega job             │
│  processa             │
│  salva resultado      │
│  espera próximo       │
│        ...            │
└──────────────────────┘
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Em vez de pensar só em scripts PHP executados sob demanda, você tem um &lt;code&gt;./my-worker&lt;/code&gt; rodando o tempo todo.&lt;/p&gt;

&lt;p&gt;Isso se aproxima do modelo que já conhecemos em aplicações Go, Rust, Node.js, Java etc.&lt;/p&gt;

&lt;p&gt;Claro que o TypePHP não transforma automaticamente qualquer aplicação PHP num servidor concorrente: networking, event loop, concorrência e comunicação continuam dependendo do runtime e das bibliotecas usadas. Mesmo assim, ter um processo nativo persistente escrito em PHP já muda bastante o jogo.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;e-as-extensoes-php&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;E as extensões PHP?&lt;/h2&gt;

&lt;p&gt;O TypePHP também gera extensões nativas. Por exemplo:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;&amp;lt;?php
function hello(string $name): string
{
    return &quot;Olá, {$name}!&quot;;
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Compilando no modo &lt;code&gt;ext&lt;/code&gt;:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;tpc hello.php --mode=ext -o hello
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;O resultado é uma extensão nativa, &lt;code&gt;hello.so&lt;/code&gt;, carregada normalmente pelo PHP:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;php -d extension=./hello.so -r &quot;echo hello(&#039;Marcos&#039;);&quot;
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Isso cria uma ponte entre o mundo PHP e o código nativo, sem precisar escrever toda a implementação em C ou C++.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;onde-isso-realmente-faz-sentido&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Onde isso realmente faz sentido?&lt;/h2&gt;

&lt;p&gt;Eu não encaro o TypePHP como uma forma de pegar uma aplicação Laravel inteira e transformá-la num executável. O cenário que faz mais sentido pra mim é outro:&lt;/p&gt;

&lt;pre&gt;&lt;code&gt;              Aplicação PHP
                    │
        ┌───────────┴───────────┐
        │                       │
   regras de negócio        processamento
   HTTP / ORM / etc.           pesado
                                │
                                ▼
                             TypePHP
                                │
                                ▼
                          código nativo
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Você continua usando PHP onde ele é excelente, mas experimenta código compilado em partes específicas, como:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;processamento de grandes volumes de dados;&lt;/li&gt;
&lt;li&gt;parsers;&lt;/li&gt;
&lt;li&gt;algoritmos e processamento numérico;&lt;/li&gt;
&lt;li&gt;workers;&lt;/li&gt;
&lt;li&gt;CLIs;&lt;/li&gt;
&lt;li&gt;agentes;&lt;/li&gt;
&lt;li&gt;ferramentas de infraestrutura;&lt;/li&gt;
&lt;li&gt;componentes que precisam ser distribuídos como binários.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;E existe uma vantagem a mais para software comercial: o cliente não precisa receber seu código PHP original. O próprio projeto cita proteção do código-fonte como uma das vantagens da compilação AOT. Isso não torna um binário impossível de analisar (engenharia reversa continua existindo), mas é bem diferente de entregar uma pasta cheia de arquivos &lt;code&gt;.php&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;e-a-performance&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;E a performance?&lt;/h2&gt;

&lt;p&gt;É a primeira coisa que vem à cabeça quando o assunto é compilação nativa, mas eu tomaria cuidado com a expectativa.&lt;/p&gt;

&lt;p&gt;Não significa que &lt;em&gt;&quot;Laravel + TypePHP = aplicação 10x mais rápida&quot;&lt;/em&gt;.&lt;/p&gt;

&lt;p&gt;Se sua aplicação passa a maior parte do tempo esperando MySQL, Redis ou APIs externas, compilar o PHP não vai resolver esse gargalo. O ganho potencial é muito mais interessante em código que realmente consome CPU:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;for ($i = 0; $i &amp;lt; 100000000; $i++) {
    $result += $i * $i;
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;O TypePHP também trabalha com tipos nativos, como &lt;code&gt;int&lt;/code&gt;, &lt;code&gt;float&lt;/code&gt; e &lt;code&gt;bool&lt;/code&gt;, e containers tipados, dando ao compilador mais informação para gerar código nativo.&lt;/p&gt;

&lt;p&gt;Eu vejo a performance como uma vantagem real do projeto, mas não como o motivo principal para acompanhar ele.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;o-que-ainda-nao-e&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;O que ainda não é&lt;/h2&gt;

&lt;p&gt;O TypePHP ainda está em desenvolvimento e trabalha com um subconjunto da linguagem PHP.&lt;/p&gt;

&lt;p&gt;Isso acontece porque PHP é extremamente dinâmico:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;$method = $foo;
$object-&amp;gt;$method();
call_user_func($callback);
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Quanto mais dinâmica é a aplicação, mais difícil é determinar em tempo de compilação o que aquele código vai fazer. Por isso, não espere pegar qualquer projeto PHP existente, especialmente uma aplicação grande e cheia de recursos dinâmicos, e simplesmente gerar um executável.&lt;/p&gt;

&lt;p&gt;TypePHP ainda não é &quot;Go escrito em PHP&quot;. Mas pode ser um caminho e tanto pro futuro da linguagem.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;para-quem-o-typephp-e-interessante&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Para quem o TypePHP é interessante?&lt;/h2&gt;

&lt;p&gt;Se você trabalha exclusivamente com Laravel, Symfony e APIs tradicionais, talvez o TypePHP não mude muita coisa no seu dia a dia, pelo menos por enquanto.&lt;/p&gt;

&lt;p&gt;Mas ele passa a fazer muito sentido se você desenvolve:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;ferramentas CLI;&lt;/li&gt;
&lt;li&gt;workers e consumidores de filas;&lt;/li&gt;
&lt;li&gt;processamento de arquivos;&lt;/li&gt;
&lt;li&gt;parsers;&lt;/li&gt;
&lt;li&gt;ferramentas de infraestrutura;&lt;/li&gt;
&lt;li&gt;agentes que ficam rodando na máquina;&lt;/li&gt;
&lt;li&gt;software comercial que precisa ser distribuído;&lt;/li&gt;
&lt;li&gt;extensões PHP;&lt;/li&gt;
&lt;li&gt;código que possui gargalos de CPU.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Nesses casos, o TypePHP deixa de ser curiosidade e vira mais uma ferramenta na caixa.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;vale-a-pena-acompanhar&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Vale a pena acompanhar?&lt;/h2&gt;

&lt;p&gt;Eu acho que sim. Não porque você deveria abandonar PHP-FPM, Laravel ou Symfony amanhã, mas porque o projeto está explorando uma possibilidade que historicamente não era muito comum no ecossistema PHP:&lt;/p&gt;

&lt;pre&gt;&lt;code&gt;             PHP
              │
       ┌──────┼──────┐
       │      │      │
       ▼      ▼      ▼
      Web   Worker   CLI
       │      │      │
    PHP-FPM binário binário
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Um desenvolvedor PHP pode continuar usando toda a experiência que já tem na linguagem e, em determinados cenários, começar a produzir software nativo.&lt;/p&gt;

&lt;p&gt;Na minha experiência com extensões PHP e ferramentas de linha de comando, já tenho algumas ideias em mente pra testar o TypePHP e gerar meus primeiros binários nativos.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;em-resumo&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Em resumo&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Você continua escrevendo PHP.&lt;/li&gt;
&lt;li&gt;O TypePHP compila para código nativo.&lt;/li&gt;
&lt;li&gt;Você pode gerar binários, extensões e bibliotecas.&lt;/li&gt;
&lt;li&gt;Código tipado pode se beneficiar de otimizações nativas.&lt;/li&gt;
&lt;li&gt;O projeto ainda está em desenvolvimento.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a id=&quot;conclusao&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Conclusão&lt;/h2&gt;

&lt;p&gt;O ponto central do TypePHP não é fazer o PHP rodar mais rápido. É a possibilidade de mudar o tipo de software que conseguimos construir e distribuir usando a linguagem.&lt;/p&gt;

&lt;p&gt;Hoje, quando pensamos em um:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;CLI;&lt;/li&gt;
&lt;li&gt;daemon;&lt;/li&gt;
&lt;li&gt;worker;&lt;/li&gt;
&lt;li&gt;agente;&lt;/li&gt;
&lt;li&gt;serviço de infraestrutura;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;é muito comum escolher Go ou Rust.&lt;/p&gt;

&lt;p&gt;Com um compilador como o TypePHP, começamos a fazer uma pergunta diferente: será que ainda precisamos trocar de linguagem, ou podemos continuar usando PHP e compilar essa parte para código nativo?&lt;/p&gt;

&lt;p&gt;Ainda é cedo para responder. Mas, como desenvolvedor PHP, é exatamente por isso que eu vou ficar de olho no TypePHP.&lt;/p&gt;

&lt;p&gt;O projeto está aberto no GitHub: &lt;a href=&quot;https://github.com/swoole/typephp&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;TypePHP&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Até a próxima e abraços! 🐘&lt;/p&gt;
</content>
        </entry>
            <entry>
            <id>https://www.marcosmarcolin.com.br/blog/php-86</id>
            <link type="text/html" rel="alternate" href="https://www.marcosmarcolin.com.br/blog/php-86" />
            <title>Descubra as principais novidades do PHP 8.6</title>
            <published>2026-08-17T00:00:00+00:00</published>
            <updated>2026-11-20T00:00:00+00:00</updated>
            <author>
                <name>Marcos Marcolin</name>
            </author>
            <summary type="html">O PHP 8.6 traz recursos como Partial Function Application, a nova Polling API, a função clamp() e sessões mais seguras por padrão, deixando a linguagem mais moderna.</summary>
            <content type="html">&lt;p&gt;O PHP 8.6 foi lançado oficialmente em 19 de novembro de 2026.&lt;/p&gt;

&lt;p&gt;Neste post, trago um resumo das principais melhorias do 8.6, com base no &lt;a href=&quot;https://www.php.net/releases/8.6/?utm_source=blog&amp;utm_medium=post&amp;utm_campaign=php86&amp;utm_id=2026&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;anúncio oficial&lt;/a&gt; e nas RFCs aprovadas. Separei o que mais faz
diferença no dia a dia, já que muita coisa foi desenvolvida ao longo do ano para deixar a linguagem mais simples, mais
rápida e mais consistente.&lt;/p&gt;

&lt;h2&gt;Sumário&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;#polling-api&quot;&gt;Polling API: uma base nativa para I/O assíncrono&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#partial-function-application&quot;&gt;Partial Function Application: aplicação parcial de funções&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#clamp&quot;&gt;Função &lt;code&gt;clamp()&lt;/code&gt;: restringindo valores dentro de um intervalo&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#sessoes-mais-seguras-por-padrao&quot;&gt;Sessões mais seguras por padrão&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#tratamento-de-erros-de-streams&quot;&gt;Tratamento de erros de streams&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#recursos-e-melhorias-adicionais&quot;&gt;Recursos e melhorias adicionais&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#descontinuacoes-e-quebras-de-compatibilidade&quot;&gt;Descontinuações e quebras de compatibilidade&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;#consideracoes-finais&quot;&gt;Considerações finais&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a id=&quot;polling-api&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Polling API: uma base nativa para I/O assíncrono&lt;/h2&gt;

&lt;p&gt;&lt;em&gt;&lt;a href=&quot;https://wiki.php.net/rfc/poll_api?utm_source=blog&amp;utm_medium=post&amp;utm_campaign=php86&amp;utm_id=2026&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;RFC&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;O PHP 8.6 traz o novo namespace &lt;code&gt;Io\Poll&lt;/code&gt;, com uma API nativa de polling para multiplexação de I/O, prometendo melhor
desempenho que o tradicional &lt;code&gt;stream_select()&lt;/code&gt;. A ideia é oferecer uma base comum que bibliotecas de baixo nível, como
ReactPHP e Amp, possam usar para gerenciar múltiplos streams, sockets e outros recursos que suportam polling.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;PHP 8.5 e anteriores:&lt;/strong&gt;&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;$read = [$server];
$write = $except = [];

stream_select($read, $write, $except, 1);

foreach ($read as $stream) {
    // trata o evento de leitura
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;&lt;strong&gt;PHP 8.6:&lt;/strong&gt;&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;use Io\Poll\{Context, Event};

$server = stream_socket_server(&#039;tcp://0.0.0.0:8080&#039;);
stream_set_blocking($server, false);

$poll = new Context();
$poll-&amp;gt;add(new StreamPollHandle($server), [Event::Read], [&#039;type&#039; =&amp;gt; &#039;server&#039;]);

while (true) {
    foreach ($poll-&amp;gt;wait(timeoutSeconds: 1) as $watcher) {
        if ($watcher-&amp;gt;getData()[&#039;type&#039;] === &#039;server&#039; &amp;amp;&amp;amp; $watcher-&amp;gt;hasTriggered(Event::Read)) {
            $client = stream_socket_accept($server);
            $poll-&amp;gt;add(new StreamPollHandle($client), [Event::Read], [&#039;type&#039; =&amp;gt; &#039;client&#039;]);
        }
    }
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Por enquanto, o PHP 8.6 lança a base da API. Handles mais específicos, como &lt;code&gt;SocketPollHandle&lt;/code&gt;, &lt;code&gt;CurlPollHandle&lt;/code&gt;,
&lt;code&gt;TimerHandle&lt;/code&gt; e &lt;code&gt;SignalHandle&lt;/code&gt;, ficam para versões futuras.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;partial-function-application&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Partial Function Application: aplicação parcial de funções&lt;/h2&gt;

&lt;p&gt;&lt;em&gt;&lt;a href=&quot;https://wiki.php.net/rfc/partial_function_application_v2?utm_source=blog&amp;utm_medium=post&amp;utm_campaign=php86&amp;utm_id=2026&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;RFC principal&lt;/a&gt; · &lt;a href=&quot;https://wiki.php.net/rfc/partial_function_application_optional_placeholder?utm_source=blog&amp;utm_medium=post&amp;utm_campaign=php86&amp;utm_id=2026&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;RFC complementar&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;O PHP 8.6 introduz a aplicação parcial de funções, permitindo criar closures a partir de uma chamada de função,
preenchendo alguns argumentos e deixando outros para depois. Isso é feito com os placeholders &lt;code&gt;?&lt;/code&gt; (um argumento) e
&lt;code&gt;...&lt;/code&gt; (os argumentos restantes, de forma variádica). Uma RFC complementar ainda deixou o comportamento mais
previsível: todo placeholder &lt;code&gt;?&lt;/code&gt; sempre gera um parâmetro obrigatório na closure resultante.&lt;/p&gt;

&lt;p&gt;Esse recurso é uma extensão natural das first-class callable syntax, adicionadas no PHP 8.1, e combina muito bem com
o pipe operator introduzido no PHP 8.5.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;PHP 8.5 e anteriores:&lt;/strong&gt;&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;function converterMoeda(float $valor, string $de, string $para): float { /* ... */ }

$paraReal = fn (float $valor, string $de): float =&amp;gt; converterMoeda($valor, $de, &#039;BRL&#039;);
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;&lt;strong&gt;PHP 8.6:&lt;/strong&gt;&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;function converterMoeda(float $valor, string $de, string $para): float { /* ... */ }

$paraReal = converterMoeda(?, ?, &#039;BRL&#039;);
$paraReal(100.0, &#039;USD&#039;);
// Equivalente a: fn(float $valor, string $de): float =&amp;gt; converterMoeda($valor, $de, &#039;BRL&#039;);

$precos = [19.90, 249.00, 5.50];
$precosEmReal = array_map(converterMoeda(?, &#039;USD&#039;, &#039;BRL&#039;), $precos);
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Vale lembrar que construtores não são suportados: não é possível criar uma closure parcial a partir de &lt;code&gt;new&lt;/code&gt;. O motivo,
segundo a própria RFC, é que construtores são invocados de forma indireta pela engine, o que tornaria o suporte bem
mais custoso, e os casos de uso para isso são raros, ainda mais com os lazy objects do PHP 8.4.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;clamp&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Função &lt;code&gt;clamp()&lt;/code&gt;: restringindo valores dentro de um intervalo&lt;/h2&gt;

&lt;p&gt;&lt;em&gt;&lt;a href=&quot;https://wiki.php.net/rfc/clamp_v2?utm_source=blog&amp;utm_medium=post&amp;utm_campaign=php86&amp;utm_id=2026&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;RFC&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;O PHP 8.6 ganha a função nativa &lt;code&gt;clamp()&lt;/code&gt;, que restringe um valor dentro de um intervalo mínimo e máximo. Se o valor
estiver fora do intervalo, ela retorna o limite mais próximo; caso contrário, retorna o próprio valor. É um caso tão
comum que sempre acabava virando uma combinação de &lt;code&gt;min()&lt;/code&gt; e &lt;code&gt;max()&lt;/code&gt; espalhada pelo código.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;PHP 8.5 e anteriores:&lt;/strong&gt;&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;$zoom = max(50, min(200, $zoom));
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;&lt;strong&gt;PHP 8.6:&lt;/strong&gt;&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;$zoom = clamp($zoom, min: 50, max: 200);

clamp(30, min: 50, max: 200); // 50
clamp(120, min: 50, max: 200); // 120
clamp(250, min: 50, max: 200); // 200
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;&lt;a id=&quot;sessoes-mais-seguras-por-padrao&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Sessões mais seguras por padrão&lt;/h2&gt;

&lt;p&gt;&lt;em&gt;&lt;a href=&quot;https://wiki.php.net/rfc/session_security_defaults?utm_source=blog&amp;utm_medium=post&amp;utm_campaign=php86&amp;utm_id=2026&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;RFC&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Três diretivas do &lt;code&gt;ext/session&lt;/code&gt; tinham implicações de segurança, mas vinham com valores padrão que deixavam aplicações
desnecessariamente expostas. O PHP 8.6 muda esses padrões para que novas instalações já nasçam mais seguras, sem
exigir nenhuma mudança de código para o caso comum.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;code&gt;session.use_strict_mode&lt;/code&gt;: de &lt;code&gt;0&lt;/code&gt; para &lt;code&gt;1&lt;/code&gt;, mitigando ataques de fixação de sessão.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;session.cookie_httponly&lt;/code&gt;: de &lt;code&gt;0&lt;/code&gt; para &lt;code&gt;1&lt;/code&gt;, dificultando o acesso ao cookie de sessão via XSS.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;session.cookie_samesite&lt;/code&gt;: de vazio para &lt;code&gt;Lax&lt;/code&gt;, mitigando ataques CSRF.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a id=&quot;tratamento-de-erros-de-streams&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Tratamento de erros de streams&lt;/h2&gt;

&lt;p&gt;&lt;em&gt;&lt;a href=&quot;https://wiki.php.net/rfc/stream_errors?utm_source=blog&amp;utm_medium=post&amp;utm_campaign=php86&amp;utm_id=2026&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;RFC&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;O tratamento de erros em streams sempre foi meio inconsistente no PHP: cada wrapper reporta falhas de um jeito
diferente (warning, notice, ou simplesmente &lt;code&gt;false&lt;/code&gt; sem contexto), o que dificulta saber exatamente o que deu errado.
O PHP 8.6 adiciona um sistema estruturado e opcional para isso, com o novo enum &lt;code&gt;StreamErrorMode&lt;/code&gt; e a classe
&lt;code&gt;StreamError&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;PHP 8.5 e anteriores:&lt;/strong&gt;&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;$stream = @fopen(&#039;arquivo.txt&#039;, &#039;r&#039;);

if ($stream === false) {
    // sem informação estruturada sobre o motivo da falha
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;&lt;strong&gt;PHP 8.6:&lt;/strong&gt;&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;$context = stream_context_create([
    &#039;stream&#039; =&amp;gt; [&#039;error_mode&#039; =&amp;gt; StreamErrorMode::Exception],
]);

try {
    $stream = fopen(&#039;arquivo.txt&#039;, &#039;r&#039;, context: $context);
} catch (StreamException $e) {
    $erro = $e-&amp;gt;getErrors()[0];
    echo $erro-&amp;gt;code-&amp;gt;name; // ex.: &quot;NotFound&quot;
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;O comportamento padrão continua sendo o atual (&lt;code&gt;StreamErrorMode::Error&lt;/code&gt;), então nada muda para quem não usar a nova
opção. O PHP 8.6 também traz as funções &lt;code&gt;stream_last_errors()&lt;/code&gt; e &lt;code&gt;stream_clear_errors()&lt;/code&gt;, para consultar e limpar os
erros armazenados fora de um bloco &lt;code&gt;try&lt;/code&gt;/&lt;code&gt;catch&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a id=&quot;recursos-e-melhorias-adicionais&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Recursos e melhorias adicionais&lt;/h2&gt;

&lt;p&gt;Além dos principais recursos do PHP 8.6, várias melhorias menores foram adicionadas para tornar o desenvolvimento mais
seguro, consistente e previsível.&lt;/p&gt;

&lt;h3&gt;Valores padrão em propriedades &lt;code&gt;readonly&lt;/code&gt;&lt;/h3&gt;

&lt;p&gt;&lt;em&gt;&lt;a href=&quot;https://wiki.php.net/rfc/readonly_property_defaults?utm_source=blog&amp;utm_medium=post&amp;utm_campaign=php86&amp;utm_id=2026&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;RFC&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Propriedades &lt;code&gt;readonly&lt;/code&gt; agora podem ter um valor padrão, o que é especialmente útil combinado com as propriedades de
interface introduzidas no PHP 8.4, permitindo declarar metadados fixos sem precisar de um construtor:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;final readonly class InvoiceExporter implements ExporterBlueprint
{
    public string $name = &#039;Invoice Exporter&#039;;
    public string $format = &#039;pdf&#039;;
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h3&gt;Nova classe &lt;code&gt;Time\Duration&lt;/code&gt;&lt;/h3&gt;

&lt;p&gt;&lt;em&gt;&lt;a href=&quot;https://wiki.php.net/rfc/duration_class?utm_source=blog&amp;utm_medium=post&amp;utm_campaign=php86&amp;utm_id=2026&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;RFC&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Classe que representa um intervalo de tempo fixo e livre de contexto (diferente do &lt;code&gt;DateInterval&lt;/code&gt;), útil para
timeouts, delays e medições. Vem com métodos como &lt;code&gt;Duration::fromSeconds()&lt;/code&gt;, &lt;code&gt;add()&lt;/code&gt; e &lt;code&gt;divideBy()&lt;/code&gt;.&lt;/p&gt;

&lt;h3&gt;&lt;code&gt;#[\Override]&lt;/code&gt; também para constantes de classe e casos de enum&lt;/h3&gt;

&lt;p&gt;&lt;em&gt;&lt;a href=&quot;https://wiki.php.net/rfc/override_constants?utm_source=blog&amp;utm_medium=post&amp;utm_campaign=php86&amp;utm_id=2026&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;RFC&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;O atributo &lt;code&gt;#[\Override]&lt;/code&gt;, que já funcionava em métodos e propriedades, agora também pode ser usado em constantes de
classe e casos de enum, ajudando a garantir que uma constante realmente esteja sobrescrevendo outra da classe pai ou
de uma interface.&lt;/p&gt;

&lt;h3&gt;Escrita em propriedades de objetos referenciados por constantes&lt;/h3&gt;

&lt;p&gt;&lt;em&gt;&lt;a href=&quot;https://wiki.php.net/rfc/const_object_property_write?utm_source=blog&amp;utm_medium=post&amp;utm_campaign=php86&amp;utm_id=2026&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;RFC&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Agora é possível alterar propriedades de um objeto guardado em uma constante de classe, mantendo a própria constante
imutável (ou seja, a referência ao objeto não pode ser trocada, só o estado interno dele):&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;const BACKING = new stdClass();

class C
{
    const O = BACKING;
}

C::O-&amp;gt;prop = 42;
var_dump(C::O-&amp;gt;prop);
// int(42)
&lt;/code&gt;&lt;/pre&gt;

&lt;h3&gt;Enums mais expressivos: &lt;code&gt;SortDirection&lt;/code&gt; e depuração personalizada&lt;/h3&gt;

&lt;p&gt;&lt;em&gt;&lt;a href=&quot;https://wiki.php.net/rfc/sort_direction_enum?utm_source=blog&amp;utm_medium=post&amp;utm_campaign=php86&amp;utm_id=2026&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;RFC&lt;/a&gt; · &lt;a href=&quot;https://wiki.php.net/rfc/debugable-enums?utm_source=blog&amp;utm_medium=post&amp;utm_campaign=php86&amp;utm_id=2026&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;RFC&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;O PHP 8.6 traz um enum nativo &lt;code&gt;SortDirection&lt;/code&gt;, com os casos &lt;code&gt;Ascending&lt;/code&gt; e &lt;code&gt;Descending&lt;/code&gt;, pensado para frameworks e
bibliotecas usarem no lugar de strings soltas ao ordenar dados:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;$query-&amp;gt;orderBy(&#039;created_at&#039;, SortDirection::Descending);
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Enums também passam a poder implementar &lt;code&gt;__debugInfo()&lt;/code&gt;, assim como classes comuns, personalizando a saída do
&lt;code&gt;var_dump()&lt;/code&gt;:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;enum StatusPedido: string
{
    case Pago = &#039;pago&#039;;

    public function __debugInfo(): array
    {
        return [self::class . &#039;::&#039; . $this-&amp;gt;name =&amp;gt; $this-&amp;gt;value];
    }
}

var_dump(StatusPedido::Pago);
// enum(StatusPedido::Pago) (1) {
//   [&quot;StatusPedido::Pago&quot;]=&amp;gt;
//   string(4) &quot;pago&quot;
// }
&lt;/code&gt;&lt;/pre&gt;

&lt;h3&gt;Erros de &lt;code&gt;json_decode()&lt;/code&gt; com localização exata&lt;/h3&gt;

&lt;p&gt;Erros de sintaxe em &lt;code&gt;json_decode()&lt;/code&gt; passam a indicar a linha e a posição exata (linha:coluna) onde o problema
ocorreu, tanto na mensagem retornada por &lt;code&gt;json_last_error_msg()&lt;/code&gt; quanto na exceção lançada com
&lt;code&gt;JSON_THROW_ON_ERROR&lt;/code&gt;. Antes, a mensagem só descrevia o tipo do erro, sem apontar onde ele estava no JSON:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;json_decode(&#039;[{&#039;);
json_last_error_msg();
// PHP 8.5 e anteriores: &quot;Syntax error&quot;
// PHP 8.6: &quot;Syntax error near location 1:3&quot;
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Isso ajuda bastante ao depurar payloads de API, webhooks ou arquivos de configuração malformados.&lt;/p&gt;

&lt;h3&gt;Novidades em Reflection, enums e funções&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Novos métodos &lt;code&gt;ReflectionProperty::isReadable()&lt;/code&gt; e &lt;code&gt;isWritable()&lt;/code&gt;, para verificar a acessibilidade de propriedades.&lt;/li&gt;
&lt;li&gt;Doc comments agora podem ser aplicados diretamente a parâmetros de função, e lidos com o novo
&lt;code&gt;ReflectionParameter::getDocComment()&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;A nova diretiva INI &lt;code&gt;error_include_args&lt;/code&gt; faz as mensagens de erro exibirem os argumentos recebidos na chamada, não
só os tipos esperados, facilitando bastante a depuração.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;pack()&lt;/code&gt; e &lt;code&gt;unpack()&lt;/code&gt; passam a aceitar os modificadores de endianness &lt;code&gt;&amp;lt;&lt;/code&gt; e &lt;code&gt;&amp;gt;&lt;/code&gt; nos códigos de inteiros (&lt;code&gt;s&lt;/code&gt;, &lt;code&gt;S&lt;/code&gt;,
&lt;code&gt;l&lt;/code&gt;, &lt;code&gt;L&lt;/code&gt;, &lt;code&gt;q&lt;/code&gt;, &lt;code&gt;Q&lt;/code&gt;) e de ponto flutuante (&lt;code&gt;f&lt;/code&gt; e &lt;code&gt;d&lt;/code&gt;).&lt;/li&gt;
&lt;li&gt;O &lt;code&gt;ext/uri&lt;/code&gt;, introduzido no PHP 8.4, recebe melhorias complementares: um &lt;code&gt;UriBuilder&lt;/code&gt; para construir URIs sem
instâncias intermediárias, detecção do tipo de URI e de host, e funções de percent-encoding sensíveis ao contexto.&lt;/li&gt;
&lt;li&gt;A extensão Sodium ganha encapsulamento de chaves pós-quântico (X-Wing e ML-KEM-768), criptografia de endereços IP
e as funções SHAKE e TurboSHAKE.&lt;/li&gt;
&lt;li&gt;Streams TLS passam a suportar retomada de sessão, chaves pré-compartilhadas (PSK) externas e early data do TLS 1.3
(0-RTT).&lt;/li&gt;
&lt;li&gt;Outras adições pontuais: novos métodos de locale no &lt;code&gt;Locale&lt;/code&gt;, &lt;code&gt;grapheme_strrev()&lt;/code&gt; e &lt;code&gt;mysqli::quote_string()&lt;/code&gt;, que
escapa e já envolve a string em aspas, assim como o &lt;code&gt;PDO::quote()&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;Melhorias de performance&lt;/h3&gt;

&lt;p&gt;Sem exigir nenhuma mudança no código, o PHP 8.6 traz algumas otimizações internas:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Chamadas de &lt;code&gt;array_map()&lt;/code&gt; com first-class callables ou aplicação parcial como callback são compiladas em loops.&lt;/li&gt;
&lt;li&gt;A engine reutiliza closures sem estado (como arrow functions simples) entre chamadas, reduzindo alocações.&lt;/li&gt;
&lt;li&gt;Chamadas de &lt;code&gt;printf()&lt;/code&gt; e a codificação de JSON ficaram mais rápidas.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a id=&quot;descontinuacoes-e-quebras-de-compatibilidade&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Descontinuações e quebras de compatibilidade&lt;/h2&gt;

&lt;h3&gt;Sintaxe e palavras reservadas&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Usar &lt;code&gt;return&lt;/code&gt; dentro de um bloco &lt;code&gt;finally&lt;/code&gt; foi descontinuado, já que ele descarta exceções silenciosamente e
sobrescreve o valor retornado pelo &lt;code&gt;try&lt;/code&gt; ou &lt;code&gt;catch&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Retornar um valor de &lt;code&gt;__construct()&lt;/code&gt; ou &lt;code&gt;__destruct()&lt;/code&gt; também foi descontinuado.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;let&lt;/code&gt; e &lt;code&gt;is&lt;/code&gt; (como nome de classe, função ou constante), &lt;code&gt;_&lt;/code&gt; (como nome de constante), &lt;code&gt;namespace&lt;/code&gt; (como constante de
classe) e &lt;code&gt;readonly&lt;/code&gt; (como nome de função) passam a ser descontinuados como identificadores, reservados para futuras
funcionalidades da linguagem, como pattern matching e escopo de bloco.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;Form Feed agora é whitespace em &lt;code&gt;trim()&lt;/code&gt;&lt;/h3&gt;

&lt;p&gt;As funções &lt;code&gt;trim()&lt;/code&gt;, &lt;code&gt;ltrim()&lt;/code&gt; e &lt;code&gt;rtrim()&lt;/code&gt; passam a remover também o caractere form feed (&lt;code&gt;\f&lt;/code&gt;, ASCII 12) por padrão,
junto com espaço, tab, quebra de linha, retorno de carro e NUL. É uma quebra de compatibilidade: código que dependia
de preservar esse caractere nas pontas de uma string precisa ser revisado.&lt;/p&gt;

&lt;h3&gt;Falhas que antes passavam em silêncio&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;&lt;code&gt;fclose()&lt;/code&gt;, &lt;code&gt;file_put_contents()&lt;/code&gt; e &lt;code&gt;copy()&lt;/code&gt; agora retornam &lt;code&gt;false&lt;/code&gt; quando o flush ou o fechamento do stream falha,
em vez de ignorar o erro.&lt;/li&gt;
&lt;li&gt;Várias funções passam a lançar &lt;code&gt;ValueError&lt;/code&gt; para valores fora do intervalo, flags inválidas ou strings com bytes NUL,
em vez de truncar ou ignorar o valor silenciosamente.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;Objetos em funções que esperam arrays&lt;/h3&gt;

&lt;p&gt;Passar objetos para funções que esperam um array, como &lt;code&gt;array_walk()&lt;/code&gt;, &lt;code&gt;array_walk_recursive()&lt;/code&gt;, &lt;code&gt;deflate_init()&lt;/code&gt;,
&lt;code&gt;inflate_init()&lt;/code&gt;, os filtros de stream zlib e bzip2, &lt;code&gt;mb_convert_variables()&lt;/code&gt; e &lt;code&gt;http_build_query()&lt;/code&gt;, agora é
descontinuado. Use &lt;code&gt;get_object_vars()&lt;/code&gt; para converter o objeto antes de passá-lo.&lt;/p&gt;

&lt;h3&gt;Funções e métodos descontinuados&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;&lt;code&gt;is_double()&lt;/code&gt;, &lt;code&gt;is_integer()&lt;/code&gt; e &lt;code&gt;is_long()&lt;/code&gt; (aliases de &lt;code&gt;is_float()&lt;/code&gt; e &lt;code&gt;is_int()&lt;/code&gt;), além de &lt;code&gt;doubleval()&lt;/code&gt; (alias de
&lt;code&gt;floatval()&lt;/code&gt;).&lt;/li&gt;
&lt;li&gt;&lt;code&gt;strcoll()&lt;/code&gt; e a flag &lt;code&gt;SORT_LOCALE_STRING&lt;/code&gt;, ligadas a comparação de strings sensível a localidade.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;metaphone()&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;O parâmetro &lt;code&gt;$case_insensitive&lt;/code&gt; de &lt;code&gt;define()&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Uso de string em &lt;code&gt;is_a()&lt;/code&gt; e &lt;code&gt;is_subclass_of()&lt;/code&gt; quando o parâmetro &lt;code&gt;$allow_string&lt;/code&gt; é &lt;code&gt;false&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Vários métodos de &lt;code&gt;Reflection&lt;/code&gt; e SPL, como &lt;code&gt;ReflectionProperty::setValue()&lt;/code&gt;/&lt;code&gt;setRawValue()&lt;/code&gt; com tipos incorretos,
&lt;code&gt;ReflectionMethod::invoke()&lt;/code&gt;/&lt;code&gt;invokeArgs()&lt;/code&gt; com objetos para métodos estáticos, métodos de &lt;code&gt;ArrayIterator&lt;/code&gt; herdados
de &lt;code&gt;ArrayObject&lt;/code&gt;, &lt;code&gt;spl_classes()&lt;/code&gt;, &lt;code&gt;spl_object_hash()&lt;/code&gt; e os métodos de CSV de &lt;code&gt;SplFileObject&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;mysqli_stmt_init()&lt;/code&gt;, &lt;code&gt;mysqli_get_charset()&lt;/code&gt; e o uso de &lt;code&gt;session_set_save_handler()&lt;/code&gt; sem os métodos &lt;code&gt;create_sid()&lt;/code&gt; e
&lt;code&gt;validateId()&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;As funções de expressão regular do mbstring (&lt;code&gt;mb_ereg()&lt;/code&gt;, &lt;code&gt;mb_split()&lt;/code&gt; e afins), já que a biblioteca Oniguruma,
usada por elas, não é mais mantida. Elas serão removidas no PHP 9.0 e devem ser substituídas por PCRE (&lt;code&gt;preg_*&lt;/code&gt;
com o modificador &lt;code&gt;u&lt;/code&gt;).&lt;/li&gt;
&lt;li&gt;Usar mais de 16 filtros em uma URL &lt;code&gt;php://filter&lt;/code&gt; sem configurar a opção de contexto &lt;code&gt;filter.max_filter_count&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a id=&quot;consideracoes-finais&quot;&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;Considerações finais&lt;/h2&gt;

&lt;p&gt;Na minha visão, o &lt;strong&gt;PHP 8.6&lt;/strong&gt; reforça o quanto a linguagem continua evoluindo de forma consistente. Os novos recursos
são úteis no dia a dia, resolvem problemas reais e deixam o código mais claro e moderno.&lt;/p&gt;

&lt;p&gt;Para a lista completa de novidades e quebras de compatibilidade, vale conferir o
&lt;a href=&quot;https://www.php.net/manual/pt_BR/migration86.php?utm_source=blog&amp;utm_medium=post&amp;utm_campaign=php86&amp;utm_id=2026&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;guia de migração para o PHP 8.6&lt;/a&gt; no manual oficial.&lt;/p&gt;

&lt;p&gt;Até a próxima!&lt;/p&gt;
</content>
        </entry>
            <entry>
            <id>https://www.marcosmarcolin.com.br/blog/sobre-o-php-velho-oeste-2026</id>
            <link type="text/html" rel="alternate" href="https://www.marcosmarcolin.com.br/blog/sobre-o-php-velho-oeste-2026" />
            <title>Como foi o PHP Velho Oeste 2026</title>
            <published>2026-08-04T00:00:00+00:00</published>
            <updated>2026-08-04T00:00:00+00:00</updated>
            <author>
                <name>Marcos Marcolin</name>
            </author>
            <summary type="html">Na quarta edição do PHP Velho Oeste, Chapecó recebeu 249 participantes em dois dias de aprendizado e networking, prova de que a comunidade PHP segue crescendo.</summary>
            <content type="html">&lt;p&gt;Um pouco atrasado por aqui, mas... nos dias 29 e 30 de maio, Chapecó recebeu a quarta edição do &lt;strong&gt;PHP Velho Oeste&lt;/strong&gt;, e aqui, como organizador e morador da cidade que sedia o evento, carrego a mesma sensação de sempre: a de ver algo que começou pequeno virar um encontro que as pessoas fazem questão de não perder.&lt;/p&gt;

&lt;p&gt;E tem uma parte que eu gosto muito e que não aparece em nenhuma foto oficial: depois que o evento encerra, a gente senta num bar pra tomar uma cerveja com vários participantes, muita gente mesmo. Sem crachá, sem correria de organização, só conversa. Alguém contando o que aprendeu numa palestra, outro comentando sobre o trabalho, risada de algum perrengue que só a equipe sabe. Esse ano teve até karaokê, e a galera mandou muito bem. Pra mim, isso faz parte do sucesso do evento tanto quanto qualquer palestra no palco. No fim, o que fica são os laços fortalecidos e as memórias guardadas em fotos.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Foram 249 participantes&lt;/strong&gt; nesta edição.&lt;/p&gt;

&lt;p&gt;O que mais me marca não é bem o número, embora ele importe, e muito. É perceber quantas pessoas voltam: gente que esteve na primeira edição, em 2023, ainda presente ano após ano, ao lado de rostos novos descobrindo o evento agora. Isso diz muito sobre o que estamos construindo: não é só um evento, é um lugar que as pessoas escolhem voltar.&lt;/p&gt;

&lt;p&gt;Nosso propósito segue o mesmo desde o início: fortalecer a comunidade PHP do Oeste de Santa Catarina e evoluir a qualidade do evento a cada edição. É uma iniciativa sem fins lucrativos, tudo que arrecadamos volta pro próprio evento, e nada disso existiria sem quem esteve lá: participantes, palestrantes, patrocinadores, apoiadores e a equipe nos bastidores.&lt;/p&gt;

&lt;p&gt;Saiba mais sobre como foi no &lt;a href=&quot;https://phpvelhoeste.com.br/2026/?utm_source=site&amp;utm_medium=linkedin&amp;utm_campaign=marcosmarcolin&amp;utm_id=2026&quot; target=&quot;_blank&quot; rel=&quot;noopener noreferrer&quot;&gt;site&lt;/a&gt; do evento.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/images/blog/php-velho-oeste-2026/1.jpg&quot; alt=&quot;PHP Velho Oeste 2026&quot; /&gt;
&lt;img src=&quot;/assets/images/blog/php-velho-oeste-2026/2.jpg&quot; alt=&quot;PHP Velho Oeste 2026&quot; /&gt;
&lt;img src=&quot;/assets/images/blog/php-velho-oeste-2026/3.jpg&quot; alt=&quot;PHP Velho Oeste 2026&quot; /&gt;
&lt;img src=&quot;/assets/images/blog/php-velho-oeste-2026/4.jpg&quot; alt=&quot;PHP Velho Oeste 2026&quot; /&gt;
&lt;img src=&quot;/assets/images/blog/php-velho-oeste-2026/5.jpg&quot; alt=&quot;PHP Velho Oeste 2026&quot; /&gt;&lt;/p&gt;
</content>
        </entry>
            <entry>
            <id>https://www.marcosmarcolin.com.br/blog/php-100-million-row-challenge</id>
            <link type="text/html" rel="alternate" href="https://www.marcosmarcolin.com.br/blog/php-100-million-row-challenge" />
            <title>🌪️ Desafio das 100 milhões de linhas em PHP</title>
            <published>2026-03-02T00:00:00+00:00</published>
            <updated>2026-03-02T00:00:00+00:00</updated>
            <author>
                <name>Marcos Marcolin</name>
            </author>
            <summary type="html">Um desafio de performance em PHP que consiste em processar 100 milhões de linhas e gerar um JSON final. Resolvi participar e explorar o problema.</summary>
            <content type="html">&lt;p&gt;&lt;strong&gt;Como você processaria 100 milhões de linhas de um arquivo CSV no menor tempo possível?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Recentemente descobri, através do LinkedIn, um desafio interessante para quem gosta de explorar performance,
eficiência e otimizações de código.&lt;/p&gt;

&lt;p&gt;Trata-se do &lt;strong&gt;100-million-row challenge in PHP&lt;/strong&gt;, um desafio inspirado em iniciativas semelhantes em outras linguagens,
mas adaptado para o ecossistema PHP.&lt;/p&gt;

&lt;p&gt;🔗 O repositório oficial do desafio está disponível
em: &lt;a href=&quot;https://github.com/tempestphp/100-million-row-challenge&quot; target=&quot;_blank&quot;&gt;
tempestphp/100-million-row-challenge&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Resolvi participar para explorar o problema, estudar diferentes abordagens de eficiência e também contribuir com a
comunidade.&lt;/p&gt;

&lt;p&gt;Se você gosta desse tipo de problema, fica aqui o convite para participar também e testar suas próprias ideias. Em algum
momento da carreira, todo desenvolvedor acaba precisando &lt;strong&gt;ler, processar e transformar grandes volumes de dados&lt;/strong&gt;, e
nesses cenários cada detalhe de implementação pode fazer diferença no desempenho final.&lt;/p&gt;

&lt;p&gt;Além disso, é um desafio que mistura &lt;strong&gt;aprendizado, competição e diversão&lt;/strong&gt;.&lt;/p&gt;

&lt;h2&gt;O desafio&lt;/h2&gt;

&lt;blockquote&gt;
  &lt;p&gt;💡 O desafio foi inspirado no &lt;strong&gt;1 Billion Row Challenge&lt;/strong&gt; da comunidade Java, mas adaptado para o ecossistema PHP.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;A proposta é simples: ler um arquivo com 100 milhões de linhas, processar essas informações e gerar um JSON final
com os dados agregados.&lt;/p&gt;

&lt;p&gt;Cada linha do arquivo contém uma &lt;em&gt;URL completa&lt;/em&gt; e um &lt;em&gt;timestamp&lt;/em&gt;.&lt;/p&gt;

&lt;p&gt;A solução deve extrair o &lt;strong&gt;path da URL&lt;/strong&gt;, agrupar os acessos &lt;strong&gt;por dia&lt;/strong&gt; e produzir um JSON no seguinte formato:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-json&quot;&gt;{
  &quot;/blog/11-million-rows-in-seconds&quot;: {
    &quot;2025-01-24&quot;: 1,
    &quot;2026-01-24&quot;: 2
  },
  &quot;/blog/php-enums&quot;: {
    &quot;2024-01-24&quot;: 1
  }
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Ou seja, cada página contém um mapa com a quantidade de visitas por data.&lt;/p&gt;

&lt;h2&gt;Regras importantes&lt;/h2&gt;

&lt;p&gt;O desafio possui algumas restrições interessantes:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A solução deve ser escrita apenas em PHP&lt;/li&gt;
&lt;li&gt;Não é permitido usar ferramentas externas&lt;/li&gt;
&lt;li&gt;O script deve funcionar apenas dentro do projeto&lt;/li&gt;
&lt;li&gt;Não é permitido utilizar FFI&lt;/li&gt;
&lt;li&gt;JIT desabilitado por padrão&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Essas restrições tornam o desafio mais interessante, pois obrigam a focar em:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;eficiência de leitura de arquivo&lt;/li&gt;
&lt;li&gt;uso de memória&lt;/li&gt;
&lt;li&gt;manipulação eficiente de strings&lt;/li&gt;
&lt;li&gt;estruturas de dados&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;Como começar&lt;/h3&gt;

&lt;p&gt;Para participar, basta fazer um fork do repositório e rodar o ambiente local.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;# Instalar dependências
composer install

# Gerar dataset de desenvolvimento(1_000_000 é o padrão)
php tempest data:generate

# Gerar um dataset maior
php tempest data:generate 50_000_000
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;O benchmark real utiliza &lt;strong&gt;100 milhões de linhas&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Depois disso, basta implementar sua solução na classe:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;final class Parser
{
    public function parse(string $inputPath, string $outputPath): void
    {
        throw new Exception(&#039;TODO&#039;);
    }
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Durante o desenvolvimento é possível executar o parser com:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;php tempest data:parse
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;E validar o resultado com:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;php tempest data:validate
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Se a validação passar, sua implementação está correta.&lt;/p&gt;

&lt;h2&gt;Rodando o desafio com Docker (opcional)&lt;/h2&gt;

&lt;p&gt;Para padronizar o ambiente e facilitar a execução do desafio, utilizei um container simples com PHP 8.5.&lt;/p&gt;

&lt;h4&gt;Dockerfile&lt;/h4&gt;

&lt;pre&gt;&lt;code class=&quot;language-dockerfile&quot;&gt;FROM php:8.5-cli-alpine

WORKDIR /app

RUN apk add --no-cache \
        git \
        icu-dev \
        $PHPIZE_DEPS \
    &amp;amp;&amp;amp; docker-php-ext-install intl \
    &amp;amp;&amp;amp; docker-php-ext-install pcntl \
    &amp;amp;&amp;amp; apk del --no-network $PHPIZE_DEPS \
    &amp;amp;&amp;amp; git config --global --add safe.directory /app \
    &amp;amp;&amp;amp; { \
        echo &quot;opcache.enable_cli=1&quot;; \
        echo &quot;opcache.jit=0&quot;; \
        echo &quot;opcache.jit_buffer_size=0&quot;; \
    } &amp;gt; /usr/local/etc/php/conf.d/99-disable-jit.ini

COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

ENV COMPOSER_ALLOW_SUPERUSER=1
&lt;/code&gt;&lt;/pre&gt;

&lt;h4&gt;docker-compose.yml&lt;/h4&gt;

&lt;pre&gt;&lt;code class=&quot;language-yaml&quot;&gt;services:
  app:
    build: .
    working_dir: /app
    volumes:
      - ./:/app
    tty: true
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Instalar dependências e executar comandos:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;docker compose run --rm app composer install
docker compose run --rm app php tempest data:generate
docker compose run --rm app php tempest data:parse
docker compose run --rm app php tempest data:validate
&lt;/code&gt;&lt;/pre&gt;

&lt;h3&gt;Enviando sua solução&lt;/h3&gt;

&lt;p&gt;A submissão é feita através de um Pull Request no repositório. O título do PR deve ser o seu &lt;em&gt;username&lt;/em&gt; do GitHub.&lt;/p&gt;

&lt;p&gt;Após validação manual, os organizadores executam o benchmark em um servidor oficial e registram o tempo no leaderboard.&lt;/p&gt;

&lt;p&gt;Também é possível solicitar uma nova execução comentando &lt;code&gt;/bench&lt;/code&gt; no PR.&lt;/p&gt;

&lt;h3&gt;Categorias e Ranking&lt;/h3&gt;

&lt;p&gt;O desafio possui duas categorias principais:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;multi-process&lt;/strong&gt;, onde a solução pode utilizar múltiplos processos (por exemplo com &lt;code&gt;pcntl&lt;/code&gt;)&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;single-thread&lt;/strong&gt;, onde a solução deve rodar utilizando apenas em um processo&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;A categoria &lt;em&gt;single-thread&lt;/em&gt; é particularmente interessante, pois permite comparar a eficiência do algoritmo sem
depender de múltiplos processos.&lt;/p&gt;

&lt;p&gt;Durante o desafio, também contribui criando um site com o ranking para facilitar a visualização dos resultados e das
soluções
submetidas: &lt;a href=&quot;https://marcosmarcolin.github.io/leaderboard-100-million-row-challenge/&quot; target=&quot;_blank&quot;&gt;PHP 100M
Row Challenge Explorer&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;A ideia foi tornar mais fácil acompanhar a evolução das submissões e explorar as diferentes implementações da
comunidade.&lt;/p&gt;

&lt;p&gt;Posteriormente, esse ranking acabou sendo &lt;strong&gt;referenciado diretamente no repositório oficial do desafio&lt;/strong&gt;.&lt;/p&gt;

&lt;h3&gt;Premiação&lt;/h3&gt;

&lt;p&gt;Os ganhadores recebem prêmios patrocinados pela JetBrains e Tideways, incluindo ElePHPants do PhpStorm e Tideways,
licenças JetBrains All Products e acesso ao Tideways Team.&lt;/p&gt;

&lt;p&gt;O desafio está aberto até 15 de março de 2026.&lt;/p&gt;

&lt;h2&gt;Conclusão&lt;/h2&gt;

&lt;p&gt;Esse tipo de desafio é interessante porque envolve processar uma quantidade considerável de dados. Situações assim
exigem atenção a diversos aspectos técnicos, como eficiência de I/O, uso de memória e estratégias para lidar com
processamento em larga escala.&lt;/p&gt;

&lt;p&gt;Resolvi participar principalmente como um exercício técnico e também para explorar diferentes abordagens para o
problema.&lt;/p&gt;

&lt;p&gt;Durante esse processo, inclusive, acabei utilizando na prática a extensão &lt;strong&gt;pcntl&lt;/strong&gt;, algo que eu já conhecia, mas ainda
não havia aplicado de fato em um projeto. Foi uma ótima oportunidade para experimentar esse tipo de abordagem e perceber
o quanto o uso de múltiplos processos pode ampliar as possibilidades de solução.&lt;/p&gt;

&lt;p&gt;No final, é um desafio que exige bastante atenção aos detalhes e um bom conhecimento da linguagem, principalmente porque
cada milissegundo pode fazer diferença no resultado final.&lt;/p&gt;

&lt;p&gt;Obrigado por ler até aqui. Nos vemos no próximo!&lt;/p&gt;
</content>
        </entry>
            <entry>
            <id>https://www.marcosmarcolin.com.br/blog/php-30-anos-larry-garfield-pt-br</id>
            <link type="text/html" rel="alternate" href="https://www.marcosmarcolin.com.br/blog/php-30-anos-larry-garfield-pt-br" />
            <title>🐘 PHP 30 Anos - Uma conversa com Larry Garfield</title>
            <published>2026-02-18T00:00:00+00:00</published>
            <updated>2026-02-18T00:00:00+00:00</updated>
            <author>
                <name>Marcos Marcolin</name>
            </author>
            <summary type="html">Entrevista da série PHP 30 Anos com Larry Garfield, uma das vozes mais respeitadas do ecossistema PHP moderno.</summary>
            <content type="html">&lt;p&gt;Esta entrevista faz parte da série &lt;strong&gt;PHP 30 Anos – Entrevista com Contribuidores&lt;/strong&gt;, criada para celebrar as três décadas
da linguagem e destacar as pessoas que ajudaram e continuam ajudando a moldar o ecossistema PHP.&lt;/p&gt;

&lt;p&gt;Larry Garfield é uma das vozes mais respeitadas do ecossistema PHP moderno.
Contribuidor de longa data do Drupal, ele liderou a iniciativa de &lt;em&gt;Web Services&lt;/em&gt; do Drupal 8, que ajudou a transformar o
Drupal em uma plataforma PHP moderna.
Ele já atuou como &lt;em&gt;Principal Engineer&lt;/em&gt; na MakersHub, &lt;em&gt;Staff Engineer&lt;/em&gt; na TYPO3 e na LegalZoom, e &lt;em&gt;Director of Developer
Experience&lt;/em&gt; na Platform.sh(agora Upsun).&lt;/p&gt;

&lt;p&gt;Larry é membro do &lt;em&gt;Core Committee&lt;/em&gt; da PHP-FIG e coautor de várias RFCs importantes do PHP, incluindo propostas relacionadas
a &lt;strong&gt;Enums&lt;/strong&gt;, &lt;strong&gt;Property Hooks&lt;/strong&gt; e ao &lt;strong&gt;Pipe Operator&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Ele também é autor de vários livros sobre PHP, incluindo &lt;em&gt;&lt;a href=&quot;https://leanpub.com/thinking-functionally-in-php&quot;&gt;Thinking Functionally in PHP&lt;/a&gt;&lt;/em&gt; e &lt;em&gt;&lt;a href=&quot;https://leanpub.com/exploringphp80&quot;&gt;Exploring PHP 8.0&lt;/a&gt;&lt;/em&gt;.&lt;/p&gt;

&lt;p&gt;A seguir, você confere a entrevista completa.&lt;/p&gt;

&lt;hr /&gt;

&lt;h3&gt;Houve algum mentor, pessoa ou referência que influenciou sua jornada com PHP?&lt;/h3&gt;

&lt;p&gt;Eu não tive um mentor específico e ativo, mas certamente fui influenciado por muitas pessoas ao longo dos anos, direta e
indiretamente.&lt;/p&gt;

&lt;p&gt;Fabien Potencier, famoso por seu trabalho com o Symfony, se destaca como alguém de quem aprendi muito, mesmo que não diretamente.&lt;/p&gt;

&lt;p&gt;Meu colaborador de RFCs, Ilija Tovilo, foi uma grande fonte de aprendizado.&lt;/p&gt;

&lt;h3&gt;Como começou a sua jornada com PHP e o que motivou você a continuar contribuindo ativamente com a linguagem?&lt;/h3&gt;

&lt;p&gt;Eu tive meu primeiro contato com PHP 3 em 1999, na faculdade, por recomendação de um amigo. Achei mais acessível do que
muitas outras coisas e, como eu já me interessava por desenvolvimento web, mergulhei de cabeça. Eventualmente, comecei a
fazer consultoria freelancer para políticos locais, e foi aí que eu passei pela fase “todo dev PHP inventa seu próprio
CMS e depois abandona”. Tenho o prazer de dizer que nenhum código meu daquela época ainda existe.&lt;/p&gt;

&lt;p&gt;Depois do mestrado e de uma breve passagem pelo jornalismo de tecnologia, consegui um emprego em uma pequena agência local
que usava PHP, embora, olhando para trás, não muito bem. Por volta dessa época (2005), eu também me envolvi com o
Drupal, inicialmente porque eu procurava um projeto do qual pudesse aprender para construir um novo BBS para o meu clube
online de RPG de Star Trek. (Sim, eu sou nerd.) No fim, acabei usando o Drupal para isso e também fui “puxado” para o
Drupal em si. Foi o primeiro projeto &lt;em&gt;Open Source&lt;/em&gt; para o qual contribuí, e eu me tornei, ao longo da década seguinte, um
dos desenvolvedores líderes. Com o tempo, em parte (mas não exclusivamente) por causa do meu envolvimento, aquela agência
cresceu e virou uma das principais consultorias de Drupal do mundo.&lt;/p&gt;

&lt;p&gt;Em 2007, no DrupalCon Sunnyvale, Rasmus Lerdorf implorou para que a comunidade Drupal abandonasse o suporte ao PHP 4 e
focasse no PHP 5, algo que poucos projetos faziam por medo de perder mercado, já que a maioria dos provedores de hospedagem (ao que parecia)
não oferecia suporte ao PHP 5. Jonah Braun, do Joomla, sugeriu para outro colega meu do Drupal, durante um piquenique,
que os projetos deveriam coordenar a migração para o PHP 5 ao mesmo tempo. Esse colega mencionou isso em um comentário de
blog, eu li, e assim começou a campanha &lt;em&gt;GoPHP5&lt;/em&gt;, para coordenar vários projetos e provedores de hospedagem se comprometendo a suportar PHP 5.2
de uma vez só (na época, a versão mais recente).&lt;/p&gt;

&lt;p&gt;Nós lançamos em 5 de janeiro de 2007 com 6 projetos e 3 provedores de hospedagem comprometidos a suportar apenas PHP 5.2 nas próximas
versões. Um mês depois, já tínhamos mais de 100 projetos e 200 provedores de hospedagem aderindo, e o time do PHP Internals tinha
decidido abandonar o suporte ao PHP 4 também. Nós conseguimos enterrar uma linguagem (PHP 4) e, eu acredito, salvamos
o PHP.&lt;/p&gt;

&lt;p&gt;Depois disso, escrevi o novo DBAL do Drupal 7, que ainda é usado até hoje. No Drupal 8, eu liderei o esforço para
modernizar a base de código, integrar componentes do Symfony e, de modo geral, reformular todo o sistema. Isso aconteceu
no pano de fundo do “Renascimento do PHP” do PHP 5.3 ao 5.6. Dezenas de pessoas, de dezenas de projetos, passaram
milhares de horas derrubando muros entre projetos PHP e criando uma comunidade mais integrada e ampla. O &lt;em&gt;Composer/Packagist&lt;/em&gt;
foi instrumental nisso, assim como o que viria a se tornar a PHP-FIG. Embora eu não tenha sido membro fundador da FIG, eu
me envolvi rapidamente e me tornei um líder de longa data desse esforço. (Eu ainda faço parte do &lt;em&gt;Core Committee&lt;/em&gt; da FIG,
tendo coescrito a maior parte do estatuto atual junto com Michael Cullom.)&lt;/p&gt;

&lt;p&gt;Infelizmente, eu deixei o Drupal em 2017 em circunstâncias nada ideais (a liderança do projeto se mostrou muito mais
preconceituosa e desonesta do que eu poderia imaginar), mas continuei ativo na comunidade mais ampla, especialmente no
circuito de conferências, onde eu palestrava com frequência em eventos pelo mundo. Nessa época eu trabalhava com
relações com desenvolvedores (&lt;em&gt;DevRel&lt;/em&gt;) em uma &lt;em&gt;startup&lt;/em&gt; de hospedagem e tocava meu trabalho com PHP em paralelo.&lt;/p&gt;

&lt;p&gt;Eu entrei na lista do PHP Internals durante o projeto &lt;em&gt;GoPHP5&lt;/em&gt;, mas eu só comecei a contribuir com o PHP em si por
volta de 2020. A primeira RFC que eu publiquei foi sobre &lt;em&gt;comprehensions&lt;/em&gt; no estilo do Python, mas ela não tinha uma
implementação significativa e a recepção foi morna, então eu abandonei. A primeira que realmente foi para frente foi
Enums, que eu colaborei com Ilija Tovilo. Ele fez o código, mas não queria se incomodar em escrever a RFC em inglês
ou discutir na &lt;em&gt;mailing list&lt;/em&gt;. Eu, felizmente, escrevo inglês técnico muito bem e não me importo de discutir. :-)
Essa foi a primeira de várias colaborações, e trabalhamos juntos desde então.&lt;/p&gt;

&lt;p&gt;Eu também autopubliquei meu primeiro livro solo, &lt;em&gt;Thinking Functionally in PHP&lt;/em&gt;, em 2020, baseado no então recém-lançado
PHP 7.4. Ele teve um sucesso razoável e, desde então, tem servido como guia para eu escolher em quais recursos trabalhar
no PHP. Como tornar PHP uma linguagem melhor para programação funcional? Como tornar técnicas funcionais mais fáceis de
usar? O Pipe Operator, partial function application, Enums e RFCs semelhantes fazem parte dessa história
maior.&lt;/p&gt;

&lt;p&gt;Embora eu tenha publicado algumas bibliotecas PHP ao longo dos anos, a mais ambiciosa foi &lt;code&gt;Crell/Serde&lt;/code&gt;, lançada em 2022.&lt;/p&gt;

&lt;p&gt;Eu comecei esse projeto originalmente enquanto trabalhava para a TYPO3, porque precisávamos de um novo
&lt;em&gt;config-loader/deserializer&lt;/em&gt; mais flexível do que qualquer coisa no mercado, então eu construí um. Claro, a TYPO3
acabou não usando, mas viva o &lt;em&gt;Open Source&lt;/em&gt;: eu ainda pude lançar o projeto.&lt;/p&gt;

&lt;hr /&gt;

&lt;h3&gt;Qual é o seu papel atualmente, e que tipo de trabalho você faz no dia a dia?&lt;/h3&gt;

&lt;p&gt;Enquanto eu escrevo isto, estou procurando um novo trabalho, então é isso que eu faço.&lt;/p&gt;

&lt;p&gt;Em paralelo, eu tenho trabalhado em uma nova ferramenta de gerenciamento de site “majoritariamente estático” para o meu
próprio blog, que eu acho que finalmente está perto de ficar pronta. (Famosas últimas palavras.) Eu também estou
trabalhando em várias RFCs do PHP, em parceria com outras pessoas, e planejando uma atualização do meu livro de
programação funcional, agora que o PHP evoluiu o suficiente para justificar isso.&lt;/p&gt;

&lt;p&gt;O que eu gostaria de estar fazendo é liderar uma equipe, ajudando as pessoas a evoluírem as próprias habilidades e a
modernizar e melhorar uma base de código mais antiga. Eu acho isso divertido, desde que a liderança não brigue comigo. Eu
sou estranho. :-)&lt;/p&gt;

&lt;hr /&gt;

&lt;h3&gt;Qual foi o maior desafio ou o momento mais marcante da sua trajetória dentro do ecossistema PHP?&lt;/h3&gt;

&lt;p&gt;Acho que não houve só um!&lt;/p&gt;

&lt;p&gt;&lt;em&gt;GoPHP5&lt;/em&gt; foi minha primeira entrada de verdade na comunidade mais ampla e, eu acho, preparou o terreno para quase tudo que
veio depois para mim: colaboração, cooperação entre projetos e empurrar a linguagem para frente. Não tinha nenhum código
ali, era só coordenação de pessoas e marketing. Mas funcionou.&lt;/p&gt;

&lt;p&gt;O trabalho que fizemos para tirar o Drupal da própria “bolha”, como parte do Renascimento do PHP, foi o próximo passo
lógico desse processo. Foram 5 anos de desgaste e, embora o resultado não tenha sido exatamente o que eu esperava, ainda
assim foi um momento definidor para o projeto e para mim pessoalmente. Foi nessa era que eu realmente me tornei
conhecido na comunidade PHP fora do Drupal.&lt;/p&gt;

&lt;p&gt;Eu defendo programação funcional desde 2011, quando dei minha primeira palestra sobre o tema em uma conferência de
Drupal. Claro, meu conhecimento nessa área cresceu bastante desde então, e com meu livro de 2020 eu consolidei uma
posição como “o cara de FP” em muitos círculos de PHP. E eu estou OK com isso, e esse é um dos fios condutores de boa
parte do meu trabalho no PHP Internals.&lt;/p&gt;

&lt;p&gt;Colocar Enums no PHP foi mais fácil do que algumas RFCs que vieram depois, mas também foi um grande ponto de virada,
quando eu me tornei “um contribuidor do core”. Eu não sei se isso me trouxe algo além de precisar de remédio para azia,
mas ainda assim foi uma sensação incrível.&lt;/p&gt;

&lt;hr /&gt;

&lt;h3&gt;O que você considera essencial para ter chegado à posição que ocupa hoje dentro do ecossistema PHP (seja no core, na Foundation ou na comunidade)?&lt;/h3&gt;

&lt;p&gt;Ingenuidade e teimosia.&lt;/p&gt;

&lt;p&gt;Não me ocorreu o quão grande o &lt;em&gt;GoPHP5&lt;/em&gt; era até eu já estar bem no meio. Eu só queria poder usar PDO para a camada de banco
de dados do Drupal. Eu não comecei querendo mudar a direção do ecossistema; eu só quis resolver uma dor. Se eu tivesse
percebido o tamanho da coisa, talvez eu nem tivesse começado. Mas, uma vez dentro, eu fui até o fim.&lt;/p&gt;

&lt;p&gt;Minha missão “oficial” no Drupal 8 era &lt;em&gt;web services&lt;/em&gt;. Eu não comecei querendo reescrever o sistema todo, mas em algum
momento isso virou o caminho para fazer &lt;em&gt;web services&lt;/em&gt; funcionar melhor, e lá fomos nós. Se eu tivesse percebido que estava
me inscrevendo para 5 anos de estresse em uma organização disfuncional, culminando em reescrever grande parte do Drupal,
talvez eu nem tivesse começado. Mas, uma vez dentro, eu fui até o fim.&lt;/p&gt;

&lt;p&gt;Eu não comecei querendo entrar em &lt;em&gt;DevRel&lt;/em&gt;, mas eu gostava de palestrar em conferências, e isso me levou a uma posição &lt;em&gt;full
time&lt;/em&gt; em &lt;em&gt;DevRel&lt;/em&gt; por 5 anos, viajando muito para vários lugares legais.&lt;/p&gt;

&lt;p&gt;Eu não comecei querendo ser “o cara de FP”. Eu só queria escrever código melhor e compartilhar o que aprendi com outras
pessoas.&lt;/p&gt;

&lt;p&gt;Como diz o velho lema dos engenheiros: “Nós fazemos essas coisas não porque elas são fáceis, mas porque achamos que seriam
fáceis.”&lt;/p&gt;

&lt;p&gt;Às vezes, “só vai” é o melhor caminho. Você não sabe o tamanho de uma tarefa até estar dentro dela. Se é importante,
tente. Às vezes você vai falhar, e tudo bem. Você chegou mais longe do que chegaria se nem tivesse tentado. E quando você
consegue, é uma sensação muito boa.&lt;/p&gt;

&lt;hr /&gt;

&lt;h3&gt;Que tipo de impacto você acredita exercer hoje no ecossistema ou na comunidade PHP?&lt;/h3&gt;

&lt;p&gt;É difícil julgar. Eu gostaria de achar que sou uma força a favor de “levar o tempo necessário para fazer direito”. O
melhor feedback que eu costumo receber é “você me fez pensar” ou “eu nunca tinha pensado assim, mas você tem razão”.&lt;/p&gt;

&lt;p&gt;Mais recentemente, eu escrevi um longo texto sobre os impactos ambientais enormes e negativos da IA no meu artigo
&lt;a href=&quot;https://www.garfieldtech.com/blog/selfish-ai&quot;&gt;Selfish AI&lt;/a&gt;, criticando quem adota IA enquanto ignora essas externalidades
negativas. Muitas pessoas me agradeceram por colocar em palavras o que elas estavam pensando.&lt;/p&gt;

&lt;p&gt;Talvez esse seja meu melhor impacto: transformar conceitos meio “escorregadios” em passos compreensíveis e deixá-los
acionáveis. Seja em coisas grandes, como “aqui está por que deveríamos converter o Drupal para OOP”, ou em coisas menores,
como “aqui está como pensar sobre &lt;code&gt;null&lt;/code&gt;” (&lt;a href=&quot;https://www.garfieldtech.com/blog/much-ado-about-null&quot;&gt;Much Ado About Null&lt;/a&gt;),
eu espero conseguir deixar as pessoas com quem eu trabalho mais inteligentes, mais habilidosas e mais abertas para tudo o
que existe por aí.&lt;/p&gt;

&lt;p&gt;Nenhum de nós sabe tudo. Todos nós sabemos muito, muito pouco, em comparação com tudo o que há para saber.&lt;/p&gt;

&lt;hr /&gt;

&lt;h2&gt;Sobre PHP e a PHP Foundation&lt;/h2&gt;

&lt;h3&gt;Na sua opinião, quais foram os avanços mais significativos do PHP nos últimos anos?&lt;/h3&gt;

&lt;p&gt;Isso pode parecer pequeno, mas &lt;em&gt;constructor property promotion&lt;/em&gt;.&lt;/p&gt;

&lt;p&gt;Antes do PHP 8.0, defender injeção de dependências de forma limpa era... honestamente, bem difícil. Fazer DI direito
envolvia digitar praticamente a mesma sequência de caracteres (tipo e nome da variável) pelo menos 4 vezes. Muitos devs,
compreensivelmente, simplesmente não queriam ter esse trabalho, e não faziam. É daí que vêm gambiarras feias como as
“facades” do Laravel.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Constructor promotion&lt;/em&gt;, embora seja “só” açúcar sintático que some na compilação, reduz esse número para 1. Ele torna
estupidamente fácil declarar “esta classe precisa de X, Y e Z”. Combinado com um bom &lt;em&gt;container&lt;/em&gt; de DI com &lt;em&gt;autowiring&lt;/em&gt;, na
maioria dos casos é: “escreve uma classe, lista o que você quer, pronto”. O benefício ergonômico disso não dá para
subestimar. (E isso também significa que as facades do Laravel hoje estão resolvendo um problema que não existe há 6 anos,
então todo mundo precisa parar de usar isso, agora mesmo.)&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Named arguments&lt;/em&gt; e &lt;em&gt;attributes&lt;/em&gt; saíram na mesma época, e os três se encaixaram perfeitamente. O 8.0 foi, de fato, uma
revolução.&lt;/p&gt;

&lt;p&gt;Mais recentemente, pode parecer autopromoção eu destacar as RFCs de &lt;em&gt;Asymmetric Visibility&lt;/em&gt; e &lt;em&gt;Property Hooks&lt;/em&gt; que eu
e Ilija escrevemos, mas, juntas (e com &lt;em&gt;interface properties&lt;/em&gt; que conseguimos no caminho), elas mudaram completamente a
forma como se escreve PHP. (Ou como poderia/deveria ser.) “Me dê informações sobre este objeto” agora é só uma &lt;em&gt;property&lt;/em&gt;.
Se ela é &lt;em&gt;backed&lt;/em&gt; por um valor real ou não é irrelevante. Ela pode ser dinâmica, cacheada ou apenas “gravável” internamente.
Ainda estamos internalizando os efeitos dessa mudança, mas é enorme.&lt;/p&gt;

&lt;p&gt;E claro, o avanço geral para um sistema de tipos mais forte, que tem sido um processo incremental por anos. Eu acredito
muito em &lt;em&gt;type-driven development&lt;/em&gt;: quanto mais lógica você consegue empurrar para o seu sistema de tipos e deixar o sistema
de tipos forçar seu código para certos formatos, menos código você precisa escrever. PHP tem o sistema de tipos com
&lt;em&gt;enforcement&lt;/em&gt; mais forte entre as principais linguagens interpretadas. Ele merece bem mais crédito por isso do que recebe.&lt;/p&gt;

&lt;hr /&gt;

&lt;h3&gt;Na sua visão, quais são os maiores desafios hoje para novos contribuidores se envolverem com o core do PHP?&lt;/h3&gt;

&lt;p&gt;O PHP é uma organização “sem estrutura”. Isso... tem prós e contras. Eu recomendo fortemente que todos leiam
“&lt;a href=&quot;https://www.jofreeman.com/joreen/tyranny.htm&quot;&gt;The Tyranny of Structurelessness&lt;/a&gt;” de Jo Freeman.&lt;/p&gt;

&lt;p&gt;Mesmo que o processo de RFC seja, em teoria, bem aberto e documentado, os “caminhos de entrada” não são claros. Existem
muitas regras informais e não escritas sobre o que é ou não aceitável, e quem, entre os revisores mais comuns, vai se
importar com o quê, e quais “portões” informais você precisa passar. (Por exemplo: quem vai implicar com a linguagem do
texto da RFC, quem vai implicar com o código, quem não vai revisar nada e só vai votar não no final sem avisar, etc.)
Se você ainda não está “dentro”, isso assusta bastante. Infelizmente, esforços para resolver isso sempre batem numa
parede.&lt;/p&gt;

&lt;p&gt;O outro grande problema é que o &lt;em&gt;codebase&lt;/em&gt; do PHP é uma bagunça. Ele não é realmente escrito em C; ele é escrito em uma
linguagem de macros feita em C, e a documentação &lt;em&gt;inline&lt;/em&gt; no código é, no melhor dos casos, mínima. De novo: existem
explicações e documentação, pelo menos para parte disso, mas muita coisa é só “leia este arquivo não documentado de 10.000
linhas com um monte de macros usando termos que você ainda não conhece, boa sorte”.&lt;/p&gt;

&lt;p&gt;Existem pessoas que conseguiram aprender o &lt;em&gt;codebase&lt;/em&gt; no estado atual. Eu invejo essas pessoas. Eu ainda me perco, até hoje,
na maior parte dele.&lt;/p&gt;

&lt;hr /&gt;

&lt;h3&gt;Como você enxerga o papel da PHP Foundation no futuro da linguagem?&lt;/h3&gt;

&lt;p&gt;A PHP Foundation foi e continua sendo absolutamente crucial para o crescimento contínuo do PHP na última meia década.
Hoje em dia, algo em torno de metade de todos os &lt;em&gt;merges&lt;/em&gt; em &lt;em&gt;php-src&lt;/em&gt; vem de um dos desenvolvedores pagos pela Foundation.
E isso não é só RFCs e outras melhorias (das quais há muitas), mas também correções de bugs e manutenção “invisível”.&lt;/p&gt;

&lt;p&gt;Eu gostaria muito que a Foundation assumisse um papel mais forte e mais de liderança no PHP. Não só no código (onde um
pouco mais de planejamento interno seria bem útil), mas também em marketing para a comunidade mais ampla. A gente
provavelmente nunca vai conseguir fazer PHP ser “cool”, mas pelo menos fazer com que ele “não seja uncool” parece
alcançável.&lt;/p&gt;

&lt;p&gt;Se o seu negócio usa PHP, você precisa doar para a Foundation. Não pouco. Esta é a nossa linguagem e, se queremos que ela
continue prosperando, precisamos coletivamente colocar o dinheiro onde está a nossa boca.&lt;/p&gt;

&lt;hr /&gt;

&lt;h3&gt;O PHP ainda carrega a fama de ser uma linguagem “velha” ou “ruim” em alguns círculos. Como você vê essa imagem atualmente?&lt;/h3&gt;

&lt;p&gt;“JavaScript é uma linguagem tão estúpida. Nem tem classes, você fica nesse inferno de callbacks, e qual é a ideia de ter
que dar &lt;code&gt;parseInt()&lt;/code&gt; em tudo?”&lt;/p&gt;

&lt;p&gt;Essa era uma crítica completamente válida ao JavaScript... em 2005. Se você tentasse fazer essa afirmação hoje, seria
ridicularizado, porque seu conhecimento está 20 anos desatualizado. (Embora a coerção de tipos ainda seja ruim.)&lt;/p&gt;

&lt;p&gt;O mesmo é verdade para o PHP... ou pelo menos deveria ser. PHP moderno, bem escrito, é uma linguagem muito, muito boa, com
a maioria dos recursos que você esperaria de uma linguagem “moderna”. Ainda existem algumas lacunas, claro; o mesmo vale
para qualquer linguagem. &lt;em&gt;PHP 8.6&lt;/em&gt; terá uma sintaxe de &lt;em&gt;partial function application&lt;/em&gt; mais flexível do que qualquer outra
linguagem que eu conheço. O sistema de tipos é notavelmente robusto, faltando apenas &lt;em&gt;generics&lt;/em&gt;, que são, bom, difíceis em
uma linguagem interpretada. (Ninguém tem isso ainda.)&lt;/p&gt;

&lt;p&gt;E ainda assim o PHP continua carregando a reputação do PHP 4, enquanto o JavaScript não carrega a reputação do JS de 2005.&lt;/p&gt;

&lt;p&gt;Francamente, essa desconexão é a maior ameaça ao PHP. A linguagem em si está bem. O ecossistema é forte. Mas a percepção
e o marketing foram fracos por 20 anos, e ainda estamos sentindo a dor de uma geração de programadores cujo único contato
com PHP foi aquele “hit-piece” do “fractal”, de 14 anos atrás.&lt;/p&gt;

&lt;p&gt;Isso não ajuda com o estado do &lt;em&gt;codebase&lt;/em&gt; do WordPress (o código PHP mais famoso e mais usado do planeta), nem com algumas
das... decisões de design interessantes do Laravel, nenhum dos quais usa a linguagem no seu máximo potencial moderno.&lt;/p&gt;

&lt;p&gt;Eu acredito firmemente que enfrentar esse problema de imagem, de forma proativa e agressiva, é o maior desafio do PHP. Não
é sobre código, é sobre percepção. É sobre ter &lt;em&gt;bootcamps&lt;/em&gt; para novos devs aprenderem PHP, da forma certa desde o começo.
(Por que JS e React são tão populares? Porque existem um milhão de &lt;em&gt;bootcamps&lt;/em&gt; que formam programadores baratos de JS e
React.)&lt;/p&gt;

&lt;p&gt;Eu queria ter tempo e energia para trabalhar nisso, mas não é exatamente onde estão minhas habilidades, e eu não tenho
disposição para fazer isso como projeto paralelo. Espero que seja uma área em que a Foundation possa ajudar, mas isso exigiria
expandir seu escopo para além do &lt;em&gt;codebase&lt;/em&gt;. Se a gente não resolver isso, vai sufocar a linguagem.&lt;/p&gt;

&lt;hr /&gt;

&lt;h3&gt;Para encerrar: qual mudança ou recurso você gostaria de ver no PHP nos próximos anos?&lt;/h3&gt;

&lt;p&gt;&lt;em&gt;Generics&lt;/em&gt;, obviamente. :-)&lt;/p&gt;

&lt;p&gt;Mas falando mais sério: a mudança mais importante que vem se formando e que precisamos empurrar mais, garantindo que
fique bem feita, é PHP em processos persistentes. FrankenPHP, Swoole, etc. fazem parte disso, mas ainda não estão
totalmente certos.&lt;/p&gt;

&lt;p&gt;Não é só sobre &lt;em&gt;async&lt;/em&gt;, embora isso seja absolutamente crítico. Nós temos &lt;em&gt;async&lt;/em&gt; há anos, mas sem um &lt;em&gt;IO&lt;/em&gt; unificado para lidar
com código bloqueante e não bloqueante, isso nunca realmente pegou. É por isso que os esforços atuais para uma nova
&lt;em&gt;Async API&lt;/em&gt; nativa são tão interessantes, embora eu ache que ainda precisam de ajustes.&lt;/p&gt;

&lt;p&gt;O modo &lt;em&gt;worker&lt;/em&gt; do FrankenPHP também faz parte do quadro e, para projetos atuais, é provavelmente o caminho mais fácil para
seguir. Os ganhos de performance são enormes, mas tão importante quanto isso é que, quando o PHP não reinicia a cada
&lt;em&gt;request&lt;/em&gt;, você pode gastar menos esforço otimizando ao extremo o &lt;em&gt;bootstrap&lt;/em&gt;.&lt;/p&gt;

&lt;p&gt;Pensa em quanto trabalho vai para compilar &lt;em&gt;containers&lt;/em&gt; de DI perfeitamente otimizados, &lt;em&gt;event dispatchers&lt;/em&gt;, &lt;em&gt;template engines&lt;/em&gt;,
etc. Agora imagine se nada disso importasse... Se levar 100 ms a mais para iniciar um processo, mas apenas uma vez, e isso
exigir 100 vezes menos esforço de código do que espremer isso para 10 ms em toda &lt;em&gt;request&lt;/em&gt;... isso é uma vitória enorme,
tanto para performance quanto para reduzir o trabalho do desenvolvedor.&lt;/p&gt;

&lt;p&gt;O FrankenPHP ainda é estritamente &lt;em&gt;request/response/end&lt;/em&gt;, pelo menos em nível de &lt;em&gt;request&lt;/em&gt;.&lt;/p&gt;

&lt;p&gt;HTTP moderno significa muitos &lt;em&gt;micro-requests&lt;/em&gt;, &lt;em&gt;websockets&lt;/em&gt;, conexões persistentes, &lt;em&gt;push events&lt;/em&gt;, e usar HTTP 3 e UDP. Esse não
é o mundo para o qual o PHP e o PHP-FPM foram criados, mas é o mundo em que precisamos conseguir jogar com facilidade.&lt;/p&gt;

&lt;p&gt;Eu quero conseguir subir um novo servidor em PHP que faça &lt;em&gt;boot&lt;/em&gt; uma vez e continue de pé, com uma API simples para subir
&lt;em&gt;websockets&lt;/em&gt; e &lt;em&gt;push events&lt;/em&gt;, e que me permita usar todas as minhas bibliotecas e conhecimento existentes sem precisar
reaprender tudo.&lt;/p&gt;

&lt;p&gt;Ainda não estamos lá. Mas estamos mais perto do que o PHP já esteve, e isso, em nível técnico, é o recurso mais importante
em que podemos estar trabalhando. Se isso significa FrankenPHP, a RFC de “true async”, algo novo construído em cima dos
dois, eu não sei. Mas é para lá que o PHP precisa ir.&lt;/p&gt;

&lt;hr /&gt;

&lt;h2&gt;Off-topic&lt;/h2&gt;

&lt;h3&gt;Há alguma ferramenta, biblioteca ou prática no ecossistema PHP que você realmente gosta de usar hoje?&lt;/h3&gt;

&lt;p&gt;Basicamente, todo projeto PHP que eu crio hoje começa com &lt;em&gt;PHPUnit&lt;/em&gt; e &lt;em&gt;PHPStan&lt;/em&gt;. Eu também tenho &lt;em&gt;PHPBench&lt;/em&gt; e
&lt;em&gt;PHPMetrics&lt;/em&gt; no meu kit padrão, embora eu não use tanto.&lt;/p&gt;

&lt;p&gt;Meu ambiente Docker quase sempre vem do &lt;a href=&quot;https://phpdocker.io/&quot;&gt;PHPDocker.io&lt;/a&gt;. (Ótimo para dev, não tenho certeza se é bom
para produção.)&lt;/p&gt;

&lt;p&gt;Eu também substituí quase totalmente &lt;em&gt;Makefiles&lt;/em&gt; por &lt;a href=&quot;https://github.com/Enrise/Taskfile&quot;&gt;Taskfiles&lt;/a&gt;. Eles são puro bash e
mais fáceis de manter, já que não precisam das gambiarras para evitar o cache “orientado a C” do GNU Make.&lt;/p&gt;

&lt;p&gt;Minha IDE preferida é o IntelliJ da JetBrains. É a versão “genérica” deles, e adicionar os plugins de PHP transforma em
PHPStorm, mas eu também tenho plugins de outras linguagens instalados.&lt;/p&gt;

&lt;p&gt;Eu não faço TDD estrito, mas sou um grande defensor de testes. Testes devem ser escritos em conjunto com o código que
está sendo testado. O que é digitado primeiro pode variar, eu faço um pouco de cada, mas eles devem ser escritos próximos
o suficiente para aparecerem no mesmo commit. Código testável é um ótimo proxy de código desacoplado, fácil de modificar,
fácil de reaproveitar, fácil de acelerar quando necessário, etc.&lt;/p&gt;

&lt;p&gt;E, claro, o &lt;em&gt;Xdebug&lt;/em&gt;, sem o qual eu estaria totalmente perdido&lt;/p&gt;

&lt;hr /&gt;

&lt;h3&gt;Quais fontes você acompanha para se manter atualizado sobre PHP e desenvolvimento de software?&lt;/h3&gt;

&lt;p&gt;Eu leio a lista do PHP Internals com frequência, naturalmente.&lt;/p&gt;

&lt;p&gt;Eu também acompanho a tag &lt;code&gt;#PHP&lt;/code&gt; no Mastodon, o que me dá bastante conteúdo para eu ver ou ignorar. Eu estou no servidor
&lt;a href=&quot;https://phpc.social/about&quot;&gt;PHPC.social&lt;/a&gt;, onde também sou um moderador de baixo nível.&lt;/p&gt;

&lt;hr /&gt;

&lt;h3&gt;Você gostaria de deixar uma mensagem para a comunidade PHP do Brasil?&lt;/h3&gt;

&lt;p&gt;O universo do PHP por muito tempo foi dominado por europeus e, em segundo lugar, por americanos. Não precisa ser assim!
Essa é a beleza do &lt;em&gt;Open Source&lt;/em&gt;. Qualquer pessoa, em qualquer lugar, pode se envolver. Ajude a revisar propostas no
Internals, lance bibliotecas, contribua com projetos existentes, blog, escreva documentação, o que combinar com seu
interesse pessoal. Você não precisa de permissão de ninguém. Você só precisa de um pouco de ingenuidade e teimosia. :-)&lt;/p&gt;

&lt;hr /&gt;

&lt;p&gt;Siga &lt;strong&gt;Larry&lt;/strong&gt; e explore seu trabalho:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://github.com/crell&quot;&gt;GitHub&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.linkedin.com/in/larry-garfield/&quot;&gt;LinkedIn&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://phpc.social/@Crell&quot;&gt;Mastodon (@Crell)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.garfieldtech.com/&quot;&gt;Garfield Tech&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content>
        </entry>
            <entry>
            <id>https://www.marcosmarcolin.com.br/blog/php-85</id>
            <link type="text/html" rel="alternate" href="https://www.marcosmarcolin.com.br/blog/php-85" />
            <title>Descubra as principais novidades do PHP 8.5</title>
            <published>2025-11-21T00:00:00+00:00</published>
            <updated>2025-11-21T00:00:00+00:00</updated>
            <author>
                <name>Marcos Marcolin</name>
            </author>
            <summary type="html">O PHP 8.5 chegou com a nova extensão URI, o pipe operator e a possibilidade de modificar propriedades ao clonar objetos, deixando o código mais simples e expressivo.</summary>
            <content type="html">&lt;p&gt;Como já virou tradição na última década, o PHP recebe uma nova versão todos os anos, e agora é a vez do &lt;strong&gt;PHP 8.5&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Se você acompanha este blog ou meu &lt;a href=&quot;https://www.linkedin.com/in/marcosmarcolin/&quot;&gt;LinkedIn&lt;/a&gt;, provavelmente já viu algumas
das novidades, pois costumo comentar as RFCs e mudanças mais importantes ao longo do ano.&lt;/p&gt;

&lt;p&gt;Neste post, trago um resumo das principais melhorias do 8.5. Separei o que mais faz diferença no dia a dia, já que muita
coisa foi desenvolvida ao longo do ano para deixar a linguagem mais simples, mais rápida e mais consistente.&lt;/p&gt;

&lt;h2&gt;Extensão URI: análise e manipulação de URLs com API moderna - &lt;a href=&quot;https://wiki.php.net/rfc/url_parsing_api?utm_source=blog&amp;amp;utm_medium=post&amp;amp;utm_campaign=php85&amp;amp;utm_id=2025&quot;&gt;RFC&lt;/a&gt;&lt;/h2&gt;

&lt;p&gt;A nova extensão &lt;code&gt;URI&lt;/code&gt; agora vem sempre disponível no PHP 8.5. Ela fornece APIs próprias para analisar e modificar URIs e
URLs seguindo os padrões RFC 3986 e WHATWG URL.&lt;/p&gt;

&lt;p&gt;A implementação garante um parsing muito mais
consistente que o &lt;code&gt;parse_url&lt;/code&gt;, que sempre teve limitações e diferenças de comportamento.&lt;/p&gt;

&lt;p&gt;PHP 8.4 e anteriores&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;$components = parse_url(&#039;https://php.net/releases/8.4/pt_BR.php&#039;);
var_dump($components[&#039;host&#039;]);
// string(7) &quot;php.net&quot;
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;PHP 8.5&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;use Uri\Rfc3986\Uri;
$uri = new Uri(&#039;https://php.net/releases/8.5/pt_BR.php&#039;);
var_dump($uri-&amp;gt;getHost());
// string(7) &quot;php.net&quot;
&lt;/code&gt;&lt;/pre&gt;

&lt;h2&gt;Operador Pipe: encadeamento mais limpo e legível - &lt;a href=&quot;https://wiki.php.net/rfc/pipe-operator-v3?utm_source=blog&amp;amp;utm_medium=post&amp;amp;utm_campaign=php85&amp;amp;utm_id=2025&quot;&gt;RFC&lt;/a&gt;&lt;/h2&gt;

&lt;p&gt;O operador pipe facilita o encadeamento de funções sem criar variáveis intermediárias e sem aninhar chamadas. O fluxo
fica de cima para baixo, muito mais fácil de ler, manter e evoluir.&lt;/p&gt;

&lt;p&gt;PHP 8.4 e anteriores&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;$title = &#039; PHP 8.5 Lançado &#039;;

$slug = strtolower(
    str_replace(&#039;.&#039;, &#039;&#039;,
        str_replace(&#039; &#039;, &#039;-&#039;,
            trim($title)
        )
    )
);

var_dump($slug);
// string(15) &quot;php-85-lançado&quot;
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;PHP 8.5&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;$title = &#039; PHP 8.5 Lançado &#039;;

$slug = $title
    |&amp;gt; trim(...)
    |&amp;gt; (fn($str) =&amp;gt; str_replace(&#039; &#039;, &#039;-&#039;, $str))
    |&amp;gt; (fn($str) =&amp;gt; str_replace(&#039;.&#039;, &#039;&#039;, $str))
    |&amp;gt; strtolower(...);

var_dump($slug);
// string(15) &quot;php-85-lançado&quot;
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Você pode conferir minha explicação completa &lt;a href=&quot;https://www.marcosmarcolin.com.br/blog/php-pipe-operator&quot;&gt;neste link&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;Clone With: modifique propriedades direto no clone - &lt;a href=&quot;https://wiki.php.net/rfc/clone_with_v2?utm_source=blog&amp;amp;utm_medium=post&amp;amp;utm_campaign=php85&amp;amp;utm_id=2025&quot;&gt;RFC&lt;/a&gt;&lt;/h2&gt;

&lt;p&gt;O PHP 8.5 introduziu a possibilidade de alterar propriedades durante a clonagem, passando um array associativo para a
função &lt;code&gt;clone()&lt;/code&gt;.
Isso simplifica o padrão de métodos “with”, muito comum em classes &lt;code&gt;readonly&lt;/code&gt;, eliminando código repetitivo para
reconstruir objetos.&lt;/p&gt;

&lt;p&gt;PHP 8.4 e anteriores&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;readonly class UserProfile
{
    public function __construct(
        public string $name,
        public string $email,
        public string $role = &#039;user&#039;,
    ) {}

    public function withRole(string $role): self
    {
        $data = get_object_vars($this);
        $data[&#039;role&#039;] = $role;

        return new self(...$data);
    }
}

$profile = new UserProfile(&#039;Marcos&#039;, &#039;marcos@example.com&#039;);
$admin = $profile-&amp;gt;withRole(&#039;admin&#039;);
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;PHP 8.5&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;readonly class UserProfile
{
    public function __construct(
        public string $name,
        public string $email,
        public string $role = &#039;user&#039;,
    ) {}

    public function withRole(string $role): self
    {
        return clone($this, [
            &#039;role&#039; =&amp;gt; $role,
        ]);
    }
}

$profile = new UserProfile(&#039;Marcos&#039;, &#039;marcolindev@gmail.com&#039;);
$admin = $profile-&amp;gt;withRole(&#039;admin&#039;);
&lt;/code&gt;&lt;/pre&gt;

&lt;h2&gt;Atributo #[\NoDiscard]: garanta que o retorno seja usado - &lt;a href=&quot;https://wiki.php.net/rfc/marking_return_value_as_important?utm_source=blog&amp;amp;utm_medium=post&amp;amp;utm_campaign=php85&amp;amp;utm_id=2025&quot;&gt;RFC&lt;/a&gt;&lt;/h2&gt;

&lt;p&gt;O atributo &lt;code&gt;#[\NoDiscard]&lt;/code&gt; permite marcar funções cujo valor retornado não deve ser ignorado. Se o retorno não for
utilizado, o PHP emitirá um aviso. Isso aumenta a segurança de APIs em que o retorno é essencial, evitando erros
silenciosos.&lt;/p&gt;

&lt;p&gt;Se você realmente quiser descartar o valor, pode usar o cast &lt;code&gt;(void)&lt;/code&gt; para deixar essa intenção explícita.&lt;/p&gt;

&lt;p&gt;PHP 8.4 e anteriores&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;function getPhpVersion(): string
{
    return &#039;PHP 8.4&#039;;
}

getPhpVersion(); // Sem warning
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;PHP 8.5&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;#[\NoDiscard]
function getPhpVersion(): string
{
    return &#039;PHP 8.5&#039;;
}

getPhpVersion();
// Warning: The return value of function getPhpVersion() should either be used or intentionally ignored
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Você pode conferir minha explicação
completa &lt;a href=&quot;https://www.marcosmarcolin.com.br/blog/novo-atributo-no-discard-php-8-5&quot;&gt;neste link&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;Closures e first-class callables em expressões constantes - &lt;a href=&quot;https://wiki.php.net/rfc/closures_in_const_expr?utm_source=blog&amp;amp;utm_medium=post&amp;amp;utm_campaign=php85&amp;amp;utm_id=2025&quot;&gt;RFC&lt;/a&gt; - &lt;a href=&quot;https://wiki.php.net/rfc/fcc_in_const_expr?utm_source=blog&amp;amp;utm_medium=post&amp;amp;utm_campaign=php85&amp;amp;utm_id=2025&quot;&gt;RFC&lt;/a&gt;&lt;/h2&gt;

&lt;p&gt;O PHP 8.5 agora permite usar closures estáticas e &lt;code&gt;first-class callables&lt;/code&gt; em expressões constantes. Isso inclui
parâmetros de atributos, valores padrão de propriedades e parâmetros, além de constantes dentro da classe.&lt;/p&gt;

&lt;p&gt;Esse recurso abre espaço para configurações mais expressivas e reutilizáveis, sem necessidade de funções auxiliares ou
blocos adicionais.&lt;/p&gt;

&lt;p&gt;PHP 8.4 e anteriores&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;class Example
{
    const HANDLER = fn() =&amp;gt; &#039;test&#039;; // Fatal error
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;PHP 8.5&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;class Example
{
    const HANDLER = (static fn() =&amp;gt; &#039;test&#039;);

    public function run(): string
    {
        return (self::HANDLER)();
    }
}

$e = new Example();
var_dump($e-&amp;gt;run()); 
// string(4) &quot;test&quot;
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Você pode conferir minha explicação
completa &lt;a href=&quot;https://www.marcosmarcolin.com.br/blog/closures-em-expressoes-constantes-php-85&quot;&gt;neste link&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;cURL Share Handles persistentes - &lt;a href=&quot;https://wiki.php.net/rfc/curl_share_persistence?utm_source=blog&amp;amp;utm_medium=post&amp;amp;utm_campaign=php85&amp;amp;utm_id=2025&quot;&gt;RFC&lt;/a&gt; - &lt;a href=&quot;https://wiki.php.net/rfc/curl_share_persistence_improvement?utm_source=blog&amp;amp;utm_medium=post&amp;amp;utm_campaign=php85&amp;amp;utm_id=2025&quot;&gt;RFC&lt;/a&gt;&lt;/h2&gt;

&lt;p&gt;O PHP 8.5 introduziu &lt;code&gt;curl_share_init_persistent()&lt;/code&gt;, que cria share handles persistentes.
Diferente de &lt;code&gt;curl_share_init()&lt;/code&gt;, esses handles não são destruídos ao final da requisição.
Se outro handle com as mesmas opções já existir, ele será reutilizado, evitando custo de inicialização e melhorando a
performance de requisições repetidas.&lt;/p&gt;

&lt;p&gt;PHP 8.4 e anteriores&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;$sh = curl_share_init();
curl_share_setopt($sh, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
curl_share_setopt($sh, CURLSHOPT_SHARE, CURL_LOCK_DATA_CONNECT);

$ch = curl_init(&#039;https://php.net/&#039;);
curl_setopt($ch, CURLOPT_SHARE, $sh);

curl_exec($ch);
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;PHP 8.5&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;$sh = curl_share_init_persistent([
    CURL_LOCK_DATA_DNS,
    CURL_LOCK_DATA_CONNECT,
]);

$ch = curl_init(&#039;https://php.net/&#039;);
curl_setopt($ch, CURLOPT_SHARE, $sh);

// Isso agora pode reutilizar a conexão de uma requisição SAPI anterior
curl_exec($ch);
&lt;/code&gt;&lt;/pre&gt;

&lt;h2&gt;Funções &lt;code&gt;array_first()&lt;/code&gt; e &lt;code&gt;array_last()&lt;/code&gt; - &lt;a href=&quot;https://wiki.php.net/rfc/array_first_last?utm_source=blog&amp;amp;utm_medium=post&amp;amp;utm_campaign=php85&amp;amp;utm_id=2025&quot;&gt;RFC&lt;/a&gt;&lt;/h2&gt;

&lt;p&gt;O PHP 8.5 ganhou duas funções novas para trabalhar com arrays: &lt;code&gt;array_first()&lt;/code&gt; e &lt;code&gt;array_last()&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Elas retornam, respectivamente, o primeiro e o último valor do array. Se o array estiver vazio, retornam &lt;code&gt;null&lt;/code&gt;, o que
facilita muito quando combinadas com o operador &lt;code&gt;??&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;PHP 8.4 e anteriores&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;$lastEvent = $events === []
    ? null
    : $events[array_key_last($events)];
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;PHP 8.5&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;$lastEvent = array_last($events);
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Você pode conferir minha explicação completa &lt;a href=&quot;https://www.marcosmarcolin.com.br/blog/php-array-first-last/&quot;&gt;neste link&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;Recursos e melhorias adicionais&lt;/h2&gt;

&lt;p&gt;Além dos principais recursos do PHP 8.5, várias melhorias menores foram adicionadas para tornar o desenvolvimento mais
seguro, consistente e previsível.&lt;/p&gt;

&lt;h3&gt;&lt;code&gt;Backtrace&lt;/code&gt; em erros fatais&lt;/h3&gt;

&lt;p&gt;Erros fatais, como tempo máximo de execução excedido, agora exibem um &lt;code&gt;backtrace&lt;/code&gt; para facilitar a investigação.&lt;/p&gt;

&lt;h3&gt;Atributos mais flexíveis&lt;/h3&gt;

&lt;p&gt;Atributos agora podem ser aplicados a constantes.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;O atributo &lt;code&gt;#[\Override]&lt;/code&gt; também pode ser usado em propriedades.&lt;/li&gt;
&lt;li&gt;O atributo &lt;code&gt;#[\Deprecated]&lt;/code&gt; passa a funcionar em traits e constantes.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;Melhorias em propriedades&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Propriedades estáticas agora suportam visibilidade assimétrica.&lt;/li&gt;
&lt;li&gt;Propriedades promovidas no construtor podem ser marcadas como final.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;Novidades em funções e API interna&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Novo método &lt;code&gt;Closure::getCurrent()&lt;/code&gt;, útil para recursão em closures.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;setcookie()&lt;/code&gt; e &lt;code&gt;setrawcookie()&lt;/code&gt; agora aceitam a chave &lt;em&gt;partitioned&lt;/em&gt;.&lt;/li&gt;
&lt;li&gt;Novas funções: &lt;code&gt;get_error_handler()&lt;/code&gt; e &lt;code&gt;get_exception_handler()&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Nova função &lt;code&gt;grapheme_levenshtein()&lt;/code&gt; para strings multibyte.&lt;/li&gt;
&lt;li&gt;Métodos novos em DOM: &lt;code&gt;Dom\Element::getElementsByClassName()&lt;/code&gt; e &lt;code&gt;Dom\Element::insertAdjacentHTML()&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;Atributo #[\DelayedTargetValidation]&lt;/h3&gt;

&lt;p&gt;O uso do atributo &lt;code&gt;#[\DelayedTargetValidation]&lt;/code&gt; permite suprimir erros de compilação de atributos aplicados a alvos inválidos, útil para extensões e atributos internos.&lt;/p&gt;

&lt;h2&gt;Descontinuações e quebras de compatibilidade&lt;/h2&gt;

&lt;h3&gt;Sintaxe e operadores&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;O operador backtick como alias de &lt;code&gt;shell_exec()&lt;/code&gt; foi descontinuado.&lt;/li&gt;
&lt;li&gt;Casts não canônicos como &lt;code&gt;(boolean)&lt;/code&gt;, &lt;code&gt;(integer)&lt;/code&gt;, &lt;code&gt;(double)&lt;/code&gt; e &lt;code&gt;(binary)&lt;/code&gt; também foram descontinuados. Use &lt;code&gt;(bool)&lt;/code&gt;,
&lt;code&gt;(int)&lt;/code&gt;, &lt;code&gt;(float)&lt;/code&gt; e &lt;code&gt;(string)&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;Ajustes no engine e sintaxe&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;A diretiva INI &lt;code&gt;disable_classes&lt;/code&gt; foi removida.&lt;/li&gt;
&lt;li&gt;Finalizar &lt;code&gt;case&lt;/code&gt; com ponto e vírgula foi descontinuado.&lt;/li&gt;
&lt;li&gt;Usar &lt;code&gt;null&lt;/code&gt; como índice de array ou ao chamar &lt;code&gt;array_key_exists()&lt;/code&gt; agora é descontinuado. Use string vazia.&lt;/li&gt;
&lt;li&gt;Não é mais possível usar &lt;code&gt;array&lt;/code&gt; e &lt;code&gt;callable&lt;/code&gt; como nomes de alias em &lt;code&gt;class_alias()&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;Serialização e lifecycle&lt;/h3&gt;

&lt;p&gt;Os métodos mágicos&lt;code&gt;__sleep()&lt;/code&gt; e &lt;code&gt;__wakeup()&lt;/code&gt; foram suavemente descontinuados. O recomendado é usar &lt;code&gt;__serialize()&lt;/code&gt; e
&lt;code&gt;__unserialize()&lt;/code&gt;.&lt;/p&gt;

&lt;h3&gt;Conversões e avisos adicionais&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Agora um aviso é emitido ao converter &lt;code&gt;NAN&lt;/code&gt; para outro tipo.&lt;/li&gt;
&lt;li&gt;Desestruturar valores que não sejam arrays (exceto &lt;code&gt;null&lt;/code&gt;) usando &lt;code&gt;[]&lt;/code&gt; ou &lt;code&gt;list()&lt;/code&gt; agora emite aviso.&lt;/li&gt;
&lt;li&gt;Conversões de &lt;code&gt;floats&lt;/code&gt; (ou &lt;code&gt;strings&lt;/code&gt; que parecem &lt;code&gt;floats&lt;/code&gt;) para &lt;code&gt;int&lt;/code&gt; que não cabem mais no tipo também geram aviso.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;Considerações finais&lt;/h2&gt;

&lt;p&gt;Na minha visão, o &lt;strong&gt;PHP 8.5&lt;/strong&gt; reforça o quanto a linguagem continua evoluindo de forma consistente. Os novos recursos são úteis no dia a dia, resolvem problemas reais e deixam o código mais claro e moderno.&lt;/p&gt;

&lt;p&gt;Acompanhar o core da linguagem segue sendo algo que gosto bastante. Mesmo sem entender todos os detalhes internos, dá para ver o cuidado com performance, segurança e qualidade do runtime.&lt;/p&gt;

&lt;p&gt;E, sinceramente, não preciso entrar naquela discussão antiga sobre o que o PHP “é ou não é”. A linguagem continua entregando, continua crescendo e segue extremamente relevante por mérito próprio.&lt;/p&gt;

&lt;p&gt;Você pode conferir todas as mudanças no&lt;br /&gt;
&lt;a href=&quot;https://www.php.net/releases/8.5/pt_BR.php?utm_source=blog&amp;amp;utm_medium=post&amp;amp;utm_campaign=php85&amp;amp;utm_id=2025&quot;&gt;site oficial do PHP&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Até a próxima!&lt;/p&gt;
</content>
        </entry>
            <entry>
            <id>https://www.marcosmarcolin.com.br/blog/php-30-anos-derick-rethans-pt-br</id>
            <link type="text/html" rel="alternate" href="https://www.marcosmarcolin.com.br/blog/php-30-anos-derick-rethans-pt-br" />
            <title>🐘 PHP 30 Anos - Entrevista com Derick Rethans</title>
            <published>2025-11-17T00:00:00+00:00</published>
            <updated>2025-11-17T00:00:00+00:00</updated>
            <author>
                <name>Marcos Marcolin</name>
            </author>
            <summary type="html">Entrevista da série PHP 30 Anos com Derick Rethans, criador e mantenedor do Xdebug e um dos grandes nomes da história do PHP.</summary>
            <content type="html">&lt;p&gt;Esta entrevista faz parte da série &lt;strong&gt;PHP 30 Anos – Entrevista com Contribuidores&lt;/strong&gt;, criada para celebrar as três décadas
da linguagem e destacar as pessoas que ajudaram e continuam ajudando a moldar o ecossistema do PHP.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Derick Rethans&lt;/strong&gt; é um dos grandes nomes da história do PHP. Criador e mantenedor do &lt;a href=&quot;https://xdebug.org/&quot;&gt;Xdebug&lt;/a&gt;, contribuidor
ativo do core, membro da &lt;a href=&quot;https://thephp.foundation/&quot;&gt;PHP Foundation&lt;/a&gt; e envolvido em várias mudanças que marcaram a evolução da linguagem.&lt;/p&gt;

&lt;p&gt;A seguir, você confere a entrevista completa.&lt;/p&gt;

&lt;hr /&gt;

&lt;h3&gt;Como começou a sua jornada com PHP e o que te motivou a continuar contribuindo ativamente com a linguagem?&lt;/h3&gt;

&lt;p&gt;Conheci o PHP quando estava na universidade e queríamos criar um site que usasse um banco de dados para armazenar
informações. As opções naquela época, por volta do ano 2000, eram bem limitadas. Existia o ASP (Classic), que custava
dinheiro e quase ninguém hospedava, e existia o PHP, algo que podíamos usar de graça e até hospedar nós mesmos.&lt;/p&gt;

&lt;p&gt;Naqueles tempos, tudo usava MySQL. E uma das funcionalidades que o MySQL ainda não tinha eram subqueries, algo como
&lt;code&gt;SELECT * FROM tabela WHERE valor IN (SELECT...)&lt;/code&gt;. Então, de forma bem ingênua, implementei isso como um recurso na
extensão do MySQL para PHP. Para mim, aquilo foi principalmente um exercício de como usar C com a API de extensões do
PHP, e esse código (felizmente) nunca entrou na distribuição oficial do PHP.&lt;/p&gt;

&lt;p&gt;A primeira contribuição real que foi aceita foi uma reformulação da antiga extensão MCrypt. Naquele momento, ela havia
mudado a forma como sua interface em C funcionava, e isso exigia muito trabalho do lado do PHP.&lt;/p&gt;

&lt;hr /&gt;

&lt;h3&gt;Qual é o seu papel atualmente, e que tipo de trabalho você faz no dia a dia?&lt;/h3&gt;

&lt;p&gt;Atualmente, sou uma das onze pessoas contratadas pela PHP Foundation para trabalhar no projeto PHP. A maior parte do meu
tempo hoje é dedicada à manutenção da infraestrutura de servidores, mas recentemente também trabalhei em melhorias na
extensão Date/Time, criei o PIE, o novo PECL e várias outras pequenas contribuições.&lt;/p&gt;

&lt;p&gt;Além do PHP, sou o criador e único mantenedor do Xdebug, a ferramenta de depuração do PHP. A cada nova versão do PHP, o
Xdebug exige ainda mais trabalho, e há sempre uma fila contínua de novos recursos para implementar.&lt;/p&gt;

&lt;p&gt;Além disso, eu também opero o &lt;a href=&quot;https://xdebug.cloud/&quot;&gt;Xdebug Cloud&lt;/a&gt;, uma solução de depuração remota pensada para equipes distribuídas que
precisam compartilhar uma máquina de desenvolvimento PHP.&lt;/p&gt;

&lt;hr /&gt;

&lt;h3&gt;Qual foi o maior desafio ou o momento mais marcante da sua trajetória dentro do ecossistema PHP?&lt;/h3&gt;

&lt;p&gt;Por meio do meu trabalho open source no core do PHP e no Xdebug, consegui oportunidades em diversas empresas.&lt;/p&gt;

&lt;p&gt;Acabei me mudando para a Noruega para trabalhar na eZ Systems e, depois que saí de lá, passei a atuar como contratado
para desenvolver extensões em PHP. Um desses contratos foi com a MongoDB, que acabou se tornando um emprego formal.
Agora que já deixei essa empresa também, continuo trabalhando com PHP pela Foundation, em contratos e, claro, no Xdebug.
O PHP é o fio condutor de toda a minha carreira.&lt;/p&gt;

&lt;hr /&gt;

&lt;h3&gt;O que você considera essencial para ter chegado à posição que ocupa hoje dentro do ecossistema PHP (seja no core, na Foundation ou na comunidade)?&lt;/h3&gt;

&lt;p&gt;As contribuições que fiz para a linguagem e a criação do Xdebug foram essenciais para eu chegar onde estou no
ecossistema PHP.&lt;/p&gt;

&lt;hr /&gt;

&lt;h3&gt;Que tipo de impacto você acredita exercer hoje no ecossistema ou na comunidade PHP?&lt;/h3&gt;

&lt;p&gt;Acredito que, com a existência da PHP Foundation, temos confiança de que o PHP continuará evoluindo pelos próximos 30
anos. Fico muito feliz por fazer parte dessa história tão longa.&lt;/p&gt;

&lt;hr /&gt;

&lt;h2&gt;Sobre o PHP e a PHP Foundation&lt;/h2&gt;

&lt;h3&gt;Na sua opinião, quais foram os avanços mais significativos do PHP nos últimos anos?&lt;/h3&gt;

&lt;p&gt;Acho que a melhor coisa que aconteceu foi a possibilidade de tipar o código de forma geral. Isso tornou possível
escrever código mais completo e profissional, além de facilitar bastante o entendimento. E, ao mesmo tempo, o PHP não
perdeu suas raízes de linguagem “hacky”, permitindo que pequenas soluções rápidas continuem sendo divertidas de
escrever.&lt;/p&gt;

&lt;hr /&gt;

&lt;h3&gt;Na sua visão, quais são os maiores desafios hoje para novos contribuidores se envolverem com o core do PHP?&lt;/h3&gt;

&lt;p&gt;O PHP, como qualquer linguagem, é complexo. Leva muito tempo até entender tudo o que está acontecendo. Com a PHP
Foundation, estamos trabalhando para melhorar a documentação, mas hoje grande parte da documentação ainda é “o próprio
código-fonte”.&lt;/p&gt;

&lt;hr /&gt;

&lt;h3&gt;Como você enxerga o papel da PHP Foundation no futuro da linguagem?&lt;/h3&gt;

&lt;p&gt;Acho muito importante ter a Foundation como estrutura de apoio. Gostaria de vê-la evoluir para também assumir a
governança do projeto de uma forma mais profissional. Hoje, não existe algo realmente definido nesse sentido, e alguns
processos ainda acontecem de maneira improvisada, dependendo da situação.&lt;/p&gt;

&lt;hr /&gt;

&lt;h3&gt;O PHP ainda carrega a fama de ser uma linguagem “velha” ou “ruim” em alguns círculos. Como você vê essa imagem atualmente?&lt;/h3&gt;

&lt;p&gt;Eu simplesmente ignoro isso. Não é uma forma útil de definir o que o PHP é. O importante é mostrar o que a linguagem PHP
é hoje.&lt;/p&gt;

&lt;hr /&gt;

&lt;h3&gt;Para encerrar: qual mudança ou recurso você gostaria de ver no PHP nos próximos anos?&lt;/h3&gt;

&lt;p&gt;Não é Generics.&lt;/p&gt;

&lt;hr /&gt;

&lt;h2&gt;Off-topic&lt;/h2&gt;

&lt;h3&gt;Quais fontes você acompanha para se manter atualizado sobre PHP e desenvolvimento de software?&lt;/h3&gt;

&lt;p&gt;Leio a lista de e-mails do internals, participo do Slack da PHP Foundation, do Discord &lt;a href=&quot;https://phpc.chat/&quot;&gt;phpc.chat&lt;/a&gt; e também frequento
grupos de usuários (locais e de outros lugares), além de conversar com as pessoas em conferências.&lt;/p&gt;

&lt;hr /&gt;

&lt;h3&gt;Você gostaria de deixar uma mensagem para a comunidade PHP do Brasil?&lt;/h3&gt;

&lt;p&gt;Aproveitei muito meu tempo palestrando em São Paulo em 2006. Preciso encontrar uma desculpa para visitar novamente!&lt;/p&gt;

&lt;hr /&gt;

&lt;p&gt;Acompanhe o &lt;strong&gt;Derick&lt;/strong&gt; e conheça seus projetos:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://github.com/derickr&quot;&gt;GitHub&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.linkedin.com/in/derickrethans&quot;&gt;LinkedIn&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://xdebug.org/&quot;&gt;Xdebug&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://derickrethans.nl/&quot;&gt;Site&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content>
        </entry>
            <entry>
            <id>https://www.marcosmarcolin.com.br/blog/participacao-dev-talks-2025</id>
            <link type="text/html" rel="alternate" href="https://www.marcosmarcolin.com.br/blog/participacao-dev-talks-2025" />
            <title>Participação no DevTalks 2025</title>
            <published>2025-11-12T00:00:00+00:00</published>
            <updated>2025-11-12T00:00:00+00:00</updated>
            <author>
                <name>Marcos Marcolin</name>
            </author>
            <summary type="html">Participei como painelista do DevTalks 2025 em Chapecó, num bate-papo sobre desafios com tecnologias novas e legadas, simplicidade e overengineering.</summary>
            <content type="html">&lt;p&gt;No último final de semana, tive a oportunidade de participar como painelista do &lt;strong&gt;DevTalks 2025&lt;/strong&gt;, dividindo o palco com grandes profissionais de empresas de Chapecó.&lt;/p&gt;

&lt;p&gt;Foi um bate-papo muito rico, &lt;strong&gt;onde pudemos compartilhar experiências sobre o dia a dia das equipes de desenvolvimento, discutir preocupações com tecnologias novas e legadas, e até abordar temas como &lt;em&gt;overengineering&lt;/em&gt;.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Agradeço pelo convite João Alfredo Zonta, e parabéns para toda à equipe pela excelente organização, o evento foi um sucesso!&lt;/p&gt;

&lt;p&gt;Fiquei muito animado em ver nascer mais um evento desse nível em Chapecó. Que venha o próximo! 👏🚀&lt;/p&gt;

&lt;p&gt;Saiba mais sobre o evento em: &lt;a href=&quot;https://devtalks.com.br/&quot;&gt;www.devtalks.com.br&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/images/blog/devtalks/2025/1.jpg&quot; alt=&quot;DevTalks 2025&quot; /&gt;
&lt;img src=&quot;/assets/images/blog/devtalks/2025/2.jpg&quot; alt=&quot;DevTalks 2025&quot; /&gt;
&lt;img src=&quot;/assets/images/blog/devtalks/2025/3.jpg&quot; alt=&quot;DevTalks 2025&quot; /&gt;
&lt;img src=&quot;/assets/images/blog/devtalks/2025/4.jpg&quot; alt=&quot;DevTalks 2025&quot; /&gt;
&lt;img src=&quot;/assets/images/blog/devtalks/2025/5.jpg&quot; alt=&quot;DevTalks 2025&quot; /&gt;
&lt;img src=&quot;/assets/images/blog/devtalks/2025/6.jpg&quot; alt=&quot;DevTalks 2025&quot; /&gt;
&lt;img src=&quot;/assets/images/blog/devtalks/2025/7.jpg&quot; alt=&quot;DevTalks 2025&quot; /&gt;&lt;/p&gt;
</content>
        </entry>
            <entry>
            <id>https://www.marcosmarcolin.com.br/blog/phpeste-2025</id>
            <link type="text/html" rel="alternate" href="https://www.marcosmarcolin.com.br/blog/phpeste-2025" />
            <title>Participei do PHPeste 2025 em Parnaíba – PI</title>
            <published>2025-10-15T00:00:00+00:00</published>
            <updated>2025-10-15T00:00:00+00:00</updated>
            <author>
                <name>Marcos Marcolin</name>
            </author>
            <summary type="html">Uma experiência incrível em Parnaíba, palestrando no PHPeste 2025 e vivenciando de perto a força da comunidade PHP no Nordeste.</summary>
            <content type="html">&lt;p&gt;No início de outubro, estive em Parnaíba - PI para participar e palestrar no &lt;strong&gt;PHPeste 2025&lt;/strong&gt;. 🐘&lt;/p&gt;

&lt;p&gt;Tive a oportunidade de palestrar com o tema &lt;strong&gt;“Contribuir transforma: como suas ações podem redefinir sua carreira”&lt;/strong&gt;, falando sobre como contribuir pode impactar nossa jornada, além de compartilhar experiências pessoais que me ajudaram a evoluir em vários aspectos profissionais e pessoais.&lt;/p&gt;

&lt;p&gt;Agradeço à PHP Piauí, comunidade responsável pela organização deste ano, que se dedicaram muito para o evento ser um sucesso. Acho muito legal que a cada edição uma comunidade diferente do Nordeste organiza o evento, fortalecendo ainda mais o espírito de colaboração.&lt;/p&gt;

&lt;p&gt;Foi minha primeira edição do evento, e pretendo voltar no próximo ano, que será no Maranhão.&lt;/p&gt;

&lt;p&gt;Além do conhecimento adquirido e compartilhado, o ponto mais alto do evento está nos laços criados e fortalecidos, no senso de comunidade, nas oportunidades que surgem e também na experiência de conhecer novos lugares e culturas.&lt;/p&gt;

&lt;p&gt;(Voltando de ~40 °C em Parnaíba pra ~15 °C em Chapecó... o corpo ainda tá processando 😅).&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/images/blog/phpeste/2025/1.jpeg&quot; alt=&quot;PHPeste 2025&quot; /&gt;
&lt;img src=&quot;/assets/images/blog/phpeste/2025/2.jpeg&quot; alt=&quot;PHPeste 2025&quot; /&gt;
&lt;img src=&quot;/assets/images/blog/phpeste/2025/3.jpeg&quot; alt=&quot;PHPeste 2025&quot; /&gt;
&lt;img src=&quot;/assets/images/blog/phpeste/2025/4.jpeg&quot; alt=&quot;PHPeste 2025&quot; /&gt;
&lt;img src=&quot;/assets/images/blog/phpeste/2025/5.jpeg&quot; alt=&quot;PHPeste 2025&quot; /&gt;
&lt;img src=&quot;/assets/images/blog/phpeste/2025/6.jpeg&quot; alt=&quot;PHPeste 2025&quot; /&gt;&lt;/p&gt;
</content>
        </entry>
            <entry>
            <id>https://www.marcosmarcolin.com.br/blog/participacao-codecon-2025</id>
            <link type="text/html" rel="alternate" href="https://www.marcosmarcolin.com.br/blog/participacao-codecon-2025" />
            <title>Participação na Codecon 2025</title>
            <published>2025-07-21T00:00:00+00:00</published>
            <updated>2025-07-21T00:00:00+00:00</updated>
            <author>
                <name>Marcos Marcolin</name>
            </author>
            <summary type="html">Participei da Codecon em Curitiba e voltei com ideias reforçadas -&gt; foco no simples, no que funciona, e no que realmente importa no desenvolvimento.</summary>
            <content type="html">&lt;p&gt;No último final de semana, pude participar em Curitiba da &lt;strong&gt;Codecon&lt;/strong&gt;, em parceria com a &lt;strong&gt;IXC Soft&lt;/strong&gt; juntamente com alguns colegas de time.&lt;/p&gt;

&lt;p&gt;Foi a primeira edição que participei, e foi uma experiência ótima. A estrutura e organização é sensacional.&lt;/p&gt;

&lt;p&gt;💡 Melhor ainda foi escutar falas importantes de alguns palestrantes, indo muitas vezes contra o que o mercado faz você (recém-chegado na área) acreditar, e indo exatamente na minha linha de pensamento:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Escreva o código mais simples possível,&lt;/strong&gt; que seja fácil de manter e testar.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Utilize as tecnologias mais simples para&lt;/strong&gt; resolver seu problema inicial, de preferência, algo que você já domine.&lt;/li&gt;
&lt;li&gt;Use a &lt;strong&gt;IA como sua assistente&lt;/strong&gt;. Ela não vai tirar o emprego de ninguém, exceto se você não souber usá-la. Ela vai errar muito, você precisa ter o mínimo de discernimento para utilizá-la.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Só pense em escalar quando você começar realmente a ter problemas reais,&lt;/strong&gt; não os que só existem na sua cabeça.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Observabilidade é muito importante&lt;/strong&gt; para tomar decisões de projeto e não atirar no escuro.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Monolito bem estruturado vai resolver a maioria dos casos.&lt;/strong&gt; Só em exceções muito específicas você vai precisar de microsserviços ou outra parafernalha.&lt;/li&gt;
&lt;li&gt;Quem está começando deve mirar em &lt;strong&gt;profundidade&lt;/strong&gt;, não em quantidade.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Parabéns a todos os envolvidos na organização!&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/images/blog/codecon-2025/1.jpeg&quot; alt=&quot;Codecon 2025&quot; /&gt;
&lt;img src=&quot;/assets/images/blog/codecon-2025/2.jpeg&quot; alt=&quot;Codecon 2025&quot; /&gt;&lt;/p&gt;
</content>
        </entry>
            <entry>
            <id>https://www.marcosmarcolin.com.br/blog/sobre-o-php-velho-oeste-2025</id>
            <link type="text/html" rel="alternate" href="https://www.marcosmarcolin.com.br/blog/sobre-o-php-velho-oeste-2025" />
            <title>Como foi o PHP Velho Oeste 2025</title>
            <published>2025-06-10T00:00:00+00:00</published>
            <updated>2025-06-10T00:00:00+00:00</updated>
            <author>
                <name>Marcos Marcolin</name>
            </author>
            <summary type="html">Em sua terceira edição, o PHP Velho Oeste reuniu quase 250 participantes em Chapecó para dois dias de conhecimento, networking e comunidade, sem fins lucrativos.</summary>
            <content type="html">&lt;p&gt;No final de maio, Chapecó sediou a terceira edição do &lt;strong&gt;PHP Velho Oeste&lt;/strong&gt;, um evento que nasceu com o propósito de fortalecer a comunidade PHP do Oeste de Santa Catarina — e que vem crescendo a cada ano.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Em 2025, reunimos quase 250 participantes&lt;/strong&gt; e conseguimos proporcionar uma experiência ainda melhor para todos os presentes. Foram dois dias de aprendizado, conexões e troca de experiências entre profissionais, entusiastas e empresas que têm em comum a paixão pelo PHP.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Nosso propósito como organização é claro: reunir a comunidade PHP, compartilhar conhecimento e criar novas oportunidades por meio do networking.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Vale reforçar que o PHP Velho Oeste é uma iniciativa sem fins lucrativos.&lt;/strong&gt; Todo valor arrecadado com ingressos e patrocínios é reinvestido no próprio evento: seja em coffee breaks mais completos, no apoio à vinda de palestrantes ou na produção de materiais exclusivos para os participantes.&lt;/p&gt;

&lt;p&gt;Nos bastidores, uma equipe comprometida trabalhou intensamente para garantir que tudo acontecesse da melhor forma possível.&lt;/p&gt;

&lt;p&gt;E por fim, um agradecimento especial a todos que tornaram essa edição possível: participantes, palestrantes, patrocinadores e apoiadores. Cada um foi essencial para o sucesso de mais um ano de evento.&lt;/p&gt;

&lt;p&gt;É muito gratificante fazer parte disso.&lt;/p&gt;

&lt;p&gt;Até a próxima! 🐘🌵🚀&lt;/p&gt;

&lt;p&gt;Saiba mais como foi no &lt;a href=&quot;https://phpvelhoeste.com.br/2025?utm_source=site&amp;amp;utm_medium=linkedin&amp;amp;utm_campaign=marcosmarcolin&amp;amp;utm_id=2025&quot;&gt;site&lt;/a&gt; do evento.&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;/assets/images/blog/php-velho-oeste-2025/1.jpeg&quot; alt=&quot;PHP Velho Oeste 2025&quot; /&gt;
&lt;img src=&quot;/assets/images/blog/php-velho-oeste-2025/2.jpeg&quot; alt=&quot;PHP Velho Oeste 2025&quot; /&gt;
&lt;img src=&quot;/assets/images/blog/php-velho-oeste-2025/3.jpeg&quot; alt=&quot;PHP Velho Oeste 2025&quot; /&gt;
&lt;img src=&quot;/assets/images/blog/php-velho-oeste-2025/4.jpeg&quot; alt=&quot;PHP Velho Oeste 2025&quot; /&gt;
&lt;img src=&quot;/assets/images/blog/php-velho-oeste-2025/5.jpeg&quot; alt=&quot;PHP Velho Oeste 2025&quot; /&gt;
&lt;img src=&quot;/assets/images/blog/php-velho-oeste-2025/6.jpeg&quot; alt=&quot;PHP Velho Oeste 2025&quot; /&gt;&lt;/p&gt;
</content>
        </entry>
            <entry>
            <id>https://www.marcosmarcolin.com.br/blog/php-pipe-operator</id>
            <link type="text/html" rel="alternate" href="https://www.marcosmarcolin.com.br/blog/php-pipe-operator" />
            <title>Operador &quot;Pipe&quot; |&gt; no PHP 8.5</title>
            <published>2025-05-18T00:00:00+00:00</published>
            <updated>2025-05-18T00:00:00+00:00</updated>
            <author>
                <name>Marcos Marcolin</name>
            </author>
            <summary type="html">O PHP 8.5 trará um novo operador, o Pipe Operator |&gt;, uma antiga proposta da linguagem finalmente implementada.</summary>
            <content type="html">&lt;p&gt;🐘 O &lt;strong&gt;PHP 8.5&lt;/strong&gt; trará um novo operador: o Pipe Operator &lt;code&gt;|&amp;gt;&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Sim, uma antiga proposta da linguagem finalmente será implementada, &lt;strong&gt;adicionando um novo operador ao PHP.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;O operador possui a seguinte sintaxe:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;&amp;lt;?php

mixed |&amp;gt; callable;
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;O operador |&gt;, conhecido como &lt;strong&gt;pipe&lt;/strong&gt;, &lt;strong&gt;avalia a expressão à esquerda e a passa como argumento para a função ou
invocável à direita,&lt;/strong&gt; retornando o resultado da chamada.&lt;/p&gt;

&lt;p&gt;Isso significa que os dois trechos de código abaixo são logicamente equivalentes:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;&amp;lt;?php

// Sem Pipe
echo strlen(&quot;Hello World&quot;); // 11
// Com Pipe
echo &quot;Hello World&quot; |&amp;gt; strlen(...); // 11

// Encadeando chamadas de funções

// Sem Pipe
$input = &quot;  Marcos Marcolin  &quot;;
$temp = trim($input);
$temp = strtolower($temp);
$temp = ucwords($temp);
echo $temp; // Marcos Marcolin

// Com Pipe
echo &quot;  Marcos Marcolin  &quot;
    |&amp;gt; trim(...)
    |&amp;gt; strtolower(...)
    |&amp;gt; ucwords(...); // Marcos Marcolin
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;À primeira vista, pode parecer pouco útil. Mas, ao encadear várias chamadas, o operador pipe torna o código muito mais
legível e expressivo:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;O lado esquerdo do operador pode ser qualquer valor ou expressão.&lt;/li&gt;
&lt;li&gt;O lado direito deve ser um invocável válido do PHP (função, método ou closure) que aceite apenas um parâmetro.&lt;/li&gt;
&lt;li&gt;Funções que exigem mais de um argumento obrigatório não são compatíveis e gerarão erro por argumentos insuficientes.&lt;/li&gt;
&lt;li&gt;Se o lado direito não for avaliado como um invocável válido, um erro será lançado.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Exemplo prático com transformação de string:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;&amp;lt;?php

// Sem pipe
$temp = &quot;Hello World&quot;;
$temp = htmlentities($temp);
$temp = str_split($temp);
$temp = array_map(strtoupper(...), $temp);
$temp = array_filter($temp, fn($v) =&amp;gt; $v != &#039;O&#039;);
$result = $temp;

// Com pipe
$result = &quot;Hello World&quot;
    |&amp;gt; htmlentities(...)
    |&amp;gt; str_split(...)
    |&amp;gt; fn($x) =&amp;gt; array_map(strtoupper(...), $x)
    |&amp;gt; fn($x) =&amp;gt; array_filter($x, fn($v) =&amp;gt; $v != &#039;O&#039;);
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Exemplo com pipe em funções e objetos:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;&amp;lt;?php

function getUsers(): array {
    return [
        new User(&#039;root&#039;, isAdmin: true),
        new User(&#039;marcos.marcolin&#039;, isAdmin: false),
    ];
}

function isAdmin(User $user): bool {
    return $user-&amp;gt;isAdmin;
}

// This is the new syntax.
$numberOfAdmins = getUsers()
    |&amp;gt; fn ($list) =&amp;gt; array_filter($list, isAdmin(...)) 
    |&amp;gt; count(...);

var_dump($numberOfAdmins); // int(1);
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Num primeiro momento, a sintaxe pode soar um pouco estranha para quem está acostumado com os operadores tradicionais.
Mas, após entender a proposta, ela se mostra uma adição elegante e poderosa à linguagem.&lt;/p&gt;

&lt;p&gt;Você pode ler mais sobre a &lt;strong&gt;RFC&lt;/strong&gt; na publicação oficial: &lt;a href=&quot;https://wiki.php.net/rfc/pipe-operator-v3&quot;&gt;clique aqui&lt;/a&gt;.&lt;/p&gt;
</content>
        </entry>
            <entry>
            <id>https://www.marcosmarcolin.com.br/blog/php-array-first-last</id>
            <link type="text/html" rel="alternate" href="https://www.marcosmarcolin.com.br/blog/php-array-first-last" />
            <title>array_first() e array_last() no PHP 8.5</title>
            <published>2025-05-07T00:00:00+00:00</published>
            <updated>2026-11-20T00:00:00+00:00</updated>
            <author>
                <name>Marcos Marcolin</name>
            </author>
            <summary type="html">PHP 8.5 terá duas novas funções para arrays — array_first() e array_last(), que facilitam o acesso ao primeiro e ao último elemento.</summary>
            <content type="html">&lt;p&gt;🐘 O &lt;strong&gt;PHP 8.5&lt;/strong&gt; terá mais duas funções de array: &lt;code&gt;array_first()&lt;/code&gt; e &lt;code&gt;array_last()&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Finalmente, teremos funções específicas para pegar o primeiro e o último elemento de um array, sem precisar usar funções sem padrão ou que alteram o array internamente.&lt;/p&gt;

&lt;p&gt;Essas funções complementam as já existentes &lt;code&gt;array_key_first()&lt;/code&gt; e &lt;code&gt;array_key_last()&lt;/code&gt;.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;&amp;lt;?php

$colors = [&#039;red&#039;, &#039;green&#039;, &#039;blue&#039;];

/* Antes do PHP 8.5 */

// Primeiro elemento
echo reset($colors); // red
echo $colors[array_key_first($colors)]; // red

// Último elemento
echo end($colors); // blue
echo $colors[array_key_last($colors)]; // blue

/* 🐘 Com PHP 8.5 */
echo array_first($colors); // red
echo array_last($colors); // blue
&lt;/code&gt;&lt;/pre&gt;

&lt;h2&gt;Atualização: as funções entraram no PHP 8.5&lt;/h2&gt;

&lt;p&gt;A RFC foi aprovada e as duas funções fazem parte do PHP 8.5, lançado em 20 de novembro de 2025. Se quiser ver o que mais chegou nessa versão, escrevi um resumo em &lt;a href=&quot;/blog/php-85&quot;&gt;novidades do PHP 8.5&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;Por que &lt;code&gt;reset()&lt;/code&gt; e &lt;code&gt;end()&lt;/code&gt; não eram suficientes&lt;/h2&gt;

&lt;p&gt;Parece pouca coisa ter duas funções novas para algo que já dava para fazer, mas as alternativas antigas tinham alguns problemas:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Alteram o ponteiro interno do array.&lt;/strong&gt; &lt;code&gt;reset()&lt;/code&gt; e &lt;code&gt;end()&lt;/code&gt; não só retornam o valor, elas movem o ponteiro. Se outro trecho do código usa &lt;code&gt;current()&lt;/code&gt;, &lt;code&gt;next()&lt;/code&gt; ou &lt;code&gt;key()&lt;/code&gt; no mesmo array, o comportamento muda sem ninguém perceber.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Recebem o array por referência.&lt;/strong&gt; Por isso, não dá para passar o retorno de uma função direto: &lt;code&gt;end(explode(&#039;,&#039;, $csv))&lt;/code&gt; gera o aviso &lt;em&gt;Only variables should be passed by reference&lt;/em&gt;. Você precisa de uma variável intermediária.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Retornam &lt;code&gt;false&lt;/code&gt; quando o array está vazio.&lt;/strong&gt; Em um array que pode conter &lt;code&gt;false&lt;/code&gt; como valor, não dá para saber se o array estava vazio ou se o primeiro elemento era mesmo &lt;code&gt;false&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Com &lt;code&gt;array_key_first()&lt;/code&gt; e &lt;code&gt;array_key_last()&lt;/code&gt; esses problemas somem, mas o código fica verboso, porque você precisa da chave para depois acessar o valor.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;array_first()&lt;/code&gt; e &lt;code&gt;array_last()&lt;/code&gt; resolvem isso: recebem o array por valor, não mexem no ponteiro interno e aceitam qualquer expressão como argumento.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;&amp;lt;?php

$csv = &#039;php,go,rust&#039;;

// Antes: precisava de uma variável intermediária
$languages = explode(&#039;,&#039;, $csv);
echo end($languages); // rust

// PHP 8.5
echo array_last(explode(&#039;,&#039;, $csv)); // rust
&lt;/code&gt;&lt;/pre&gt;

&lt;h2&gt;E com array vazio?&lt;/h2&gt;

&lt;p&gt;As duas funções retornam &lt;code&gt;null&lt;/code&gt; quando o array está vazio:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;&amp;lt;?php

var_dump(array_first([])); // NULL
var_dump(array_last([]));  // NULL
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Se o seu array pode conter &lt;code&gt;null&lt;/code&gt; como valor válido, o retorno sozinho não basta para diferenciar os dois casos. Nessa situação, confira antes se o array está vazio ou use &lt;code&gt;array_key_first()&lt;/code&gt;, que retorna &lt;code&gt;null&lt;/code&gt; apenas quando não há elementos.&lt;/p&gt;

&lt;h2&gt;Arrays associativos e chaves fora de ordem&lt;/h2&gt;

&lt;p&gt;As funções consideram a &lt;strong&gt;ordem dos elementos no array&lt;/strong&gt;, e não o valor das chaves. Isso vale para arrays associativos e para listas com índices fora de ordem:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;&amp;lt;?php

$user = [&#039;name&#039; =&amp;gt; &#039;Marcos&#039;, &#039;role&#039; =&amp;gt; &#039;dev&#039;, &#039;country&#039; =&amp;gt; &#039;BR&#039;];

echo array_first($user); // Marcos
echo array_last($user);  // BR

$scores = [10 =&amp;gt; &#039;a&#039;, 2 =&amp;gt; &#039;b&#039;, 7 =&amp;gt; &#039;c&#039;];

echo array_first($scores); // a (primeiro inserido, não a menor chave)
echo array_last($scores);  // c
&lt;/code&gt;&lt;/pre&gt;

&lt;h2&gt;Usando em versões anteriores do PHP&lt;/h2&gt;

&lt;p&gt;Se o seu projeto ainda roda em uma versão anterior ao 8.5, dá para criar um &lt;em&gt;polyfill&lt;/em&gt; simples, que só é declarado quando a função nativa não existe:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;&amp;lt;?php

if (!function_exists(&#039;array_first&#039;)) {
    function array_first(array $array): mixed
    {
        foreach ($array as $value) {
            return $value;
        }

        return null;
    }
}

if (!function_exists(&#039;array_last&#039;)) {
    function array_last(array $array): mixed
    {
        return $array === [] ? null : $array[array_key_last($array)];
    }
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Quando o projeto atualizar para o PHP 8.5, as funções nativas passam a ser usadas automaticamente, sem mudar nenhuma chamada.&lt;/p&gt;

&lt;p&gt;Você pode ler mais sobre a RFC na publicação oficial: &lt;a href=&quot;https://wiki.php.net/rfc/array_first_last&quot;&gt;clique aqui&lt;/a&gt;.&lt;/p&gt;
</content>
        </entry>
            <entry>
            <id>https://www.marcosmarcolin.com.br/blog/php-escrito-em-php</id>
            <link type="text/html" rel="alternate" href="https://www.marcosmarcolin.com.br/blog/php-escrito-em-php" />
            <title>🧪 PHP sendo escrito em... PHP?</title>
            <published>2025-04-01T00:00:00+00:00</published>
            <updated>2026-11-20T00:00:00+00:00</updated>
            <author>
                <name>Marcos Marcolin</name>
            </author>
            <summary type="html">Não é pegadinha de 1º de abril, essa proposta é real. Uma PoC no Core do PHP propõe implementar funções internas em PHP puro, em vez de C.</summary>
            <content type="html">&lt;p&gt;Uma PoC (prova de conceito) recente no Core do PHP me chamou atenção: &lt;strong&gt;a implementação de funções internas usando PHP
puro, em vez de C.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Link da proposta (PoC): &lt;a href=&quot;https://github.com/php/php-src/pull/18204&quot;&gt;PR 18204&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Um exemplo prático foi a reescrita de algumas funções &lt;code&gt;array_*()&lt;/code&gt; inteiramente em PHP.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Sim, PHP implementando partes do próprio PHP.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;O objetivo não é substituir o C (afinal, o interpretador da linguagem é escrito nele), mas abrir espaço para que
algumas funções internas possam ser escritas diretamente em PHP, sem impacto relevante em desempenho.&lt;/p&gt;

&lt;p&gt;Isso pode:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Reduzir a complexidade&lt;/li&gt;
&lt;li&gt;Facilitar a colaboração&lt;/li&gt;
&lt;li&gt;Tornar o código interno mais acessível (inclusive para IDEs)&lt;/li&gt;
&lt;li&gt;Diminuir o custo de manutenção e a chance de bugs&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Na prática, isso quebra uma barreira que existe hoje para quem quer contribuir com o Core, mas não tem tanta
familiaridade com C, sistemas ou compiladores.&lt;/p&gt;

&lt;p&gt;Claro: ainda é uma prova de conceito e está em discussão.&lt;/p&gt;

&lt;h2&gt;Como as funções internas são escritas hoje&lt;/h2&gt;

&lt;p&gt;Quando você chama &lt;code&gt;array_map()&lt;/code&gt;, &lt;code&gt;str_contains()&lt;/code&gt; ou &lt;code&gt;json_encode()&lt;/code&gt;, está executando código C. Essas funções ficam nas extensões do &lt;code&gt;php-src&lt;/code&gt; (as funções de array, por exemplo, em &lt;code&gt;ext/standard/array.c&lt;/code&gt;) e são escritas usando a Zend API, a camada que o interpretador expõe para manipular arrays, strings, objetos e contagem de referências.&lt;/p&gt;

&lt;p&gt;Junto com o C, cada extensão tem arquivos &lt;code&gt;.stub.php&lt;/code&gt;, que descrevem as assinaturas das funções em sintaxe PHP. Eles servem para gerar os metadados de argumentos e tipos e são o que IDEs e ferramentas de análise estática acabam lendo. Ou seja, já existe PHP no meio do caminho, mas só para descrever as funções, não para implementá-las.&lt;/p&gt;

&lt;p&gt;Para contribuir com uma função nova hoje, você precisa entender C, a Zend API, o gerenciamento de memória do engine e as macros que o código usa. É uma barreira de entrada alta.&lt;/p&gt;

&lt;h2&gt;O que a PoC propõe&lt;/h2&gt;

&lt;p&gt;O PR reescreve &lt;code&gt;array_find()&lt;/code&gt; e funções relacionadas em PHP puro e remove a implementação em C. A versão em PHP fica muito próxima do que qualquer dev escreveria na &lt;em&gt;userland&lt;/em&gt;:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;&amp;lt;?php

function array_find(array $array, callable $callback): mixed
{
    foreach ($array as $key =&amp;gt; $value) {
        if ($callback($value, $key)) {
            return $value;
        }
    }

    return null;
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Para comparar, a versão em C precisa lidar com a iteração pela HashTable, a chamada do &lt;em&gt;callback&lt;/em&gt; pela Zend API, a contagem de referências do retorno e o tratamento de exceções. Faz a mesma coisa, só que com muito mais código e muito mais lugares onde um erro pode passar.&lt;/p&gt;

&lt;p&gt;Na PoC, esse código é carregado pelo &lt;em&gt;preloading&lt;/em&gt; do OPcache, então ele já está compilado quando o script começa. Uma versão de produção provavelmente usaria um mecanismo parecido.&lt;/p&gt;

&lt;h2&gt;E o desempenho?&lt;/h2&gt;

&lt;p&gt;A intuição diz que C é sempre mais rápido, mas não é bem assim para funções que recebem &lt;em&gt;callbacks&lt;/em&gt;. Quando uma função em C chama uma closure escrita em PHP, o engine precisa sair do código nativo, entrar de novo na máquina virtual, executar a closure e voltar. Fazer isso a cada elemento custa caro.&lt;/p&gt;

&lt;p&gt;Quando a função inteira está em PHP, o loop e a chamada do &lt;em&gt;callback&lt;/em&gt; acontecem dentro da própria máquina virtual. Com o JIT habilitado, a diferença pode ficar ainda menor. O autor da PoC incluiu benchmarks comparando as duas versões, e o argumento central é justamente esse: para esse tipo de função, escrever em PHP não traz perda relevante.&lt;/p&gt;

&lt;p&gt;Isso não vale para tudo. Funções que fazem muito processamento sem chamar código do usuário, como hash, compressão ou parsing, continuam sendo melhores em C.&lt;/p&gt;

&lt;h2&gt;Os desafios&lt;/h2&gt;

&lt;p&gt;A ideia é boa, mas tem pontos em aberto que fazem parte da discussão:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Comportamento idêntico.&lt;/strong&gt; A versão em PHP precisa se comportar exatamente como a versão em C: mesmos erros, mesmas mensagens, mesmo comportamento com &lt;code&gt;strict_types&lt;/code&gt;. Qualquer diferença é uma quebra de compatibilidade.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Custo de inicialização.&lt;/strong&gt; O código PHP precisa ser compilado em algum momento. Sem OPcache, isso aconteceria em toda requisição.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Stack traces.&lt;/strong&gt; Uma função interna em PHP pode aparecer nos rastros de erro de um jeito diferente do que o pessoal está acostumado.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Onde parar.&lt;/strong&gt; É preciso definir critérios claros de quais funções fazem sentido em PHP e quais devem continuar em C.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Até esta atualização, a proposta segue como prova de conceito e não virou uma RFC aprovada. Mesmo assim, acho a discussão valiosa: ela questiona a ideia de que tudo no núcleo precisa ser escrito em C e pode abrir a porta do Core para muito mais gente da comunidade.&lt;/p&gt;
</content>
        </entry>
            <entry>
            <id>https://www.marcosmarcolin.com.br/blog/software-legado</id>
            <link type="text/html" rel="alternate" href="https://www.marcosmarcolin.com.br/blog/software-legado" />
            <title>🦖⚠️ O código é velho — mas o aprendizado é novo</title>
            <published>2025-03-31T00:00:00+00:00</published>
            <updated>2026-11-20T00:00:00+00:00</updated>
            <author>
                <name>Marcos Marcolin</name>
            </author>
            <summary type="html">💡🔨 Trabalhar com software legado me ensinou lições valiosas que nem sempre vêm com projetos novos.</summary>
            <content type="html">&lt;p&gt;O que muitos devs pensam sobre &lt;strong&gt;Software Legado&lt;/strong&gt;:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Código bagunçado&lt;/li&gt;
&lt;li&gt;Falta de testes&lt;/li&gt;
&lt;li&gt;Medo de encostar&lt;/li&gt;
&lt;li&gt;“Coisa velha, quero distância!”&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;✅ Mas eu enxergo diferente.&lt;/p&gt;

&lt;p&gt;🔨 Trabalhar com software legado me ensinou lições valiosas que nem sempre vêm com projetos novos.&lt;/p&gt;

&lt;p&gt;O legado exige cuidado, pequenas alterações podem ter grandes impactos.&lt;/p&gt;

&lt;p&gt;Mas para quem encara, os aprendizados são muitos:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Aprender a ler código com empatia — entendendo decisões antigas, o contexto de negócio e limitações técnicas&lt;/li&gt;
&lt;li&gt;Desenvolver a habilidade de refatorar com responsabilidade, aos poucos e sem quebrar tudo&lt;/li&gt;
&lt;li&gt;Valorizar mais a documentação e o versionamento&lt;/li&gt;
&lt;li&gt;Entender o impacto real de cada mudança em sistemas que estão no ar e atendem milhares de usuários&lt;/li&gt;
&lt;li&gt;Otimizar partes lentas, remover código morto e entregar valor direto ao negócio&lt;/li&gt;
&lt;li&gt;E ganhar algo que só o tempo e a prática proporcionam: experiência real com sistemas vivos&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;Na prática: como mexer em código legado com segurança&lt;/h2&gt;

&lt;p&gt;Falar sobre aprendizado é fácil. O difícil é o dia a dia: abrir um arquivo de milhares de linhas, sem testes, e precisar mudar uma regra de negócio. Algumas práticas ajudam muito nesse cenário.&lt;/p&gt;

&lt;h3&gt;Entenda antes de mudar&lt;/h3&gt;

&lt;p&gt;Antes de alterar qualquer coisa, vale descobrir por que o código está daquele jeito. O histórico do Git costuma ter a resposta:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-shell&quot;&gt;# Quem alterou cada linha e em qual commit
git blame src/Billing/InvoiceCalculator.php

# Histórico de um trecho específico do arquivo
git log -L 120,180:src/Billing/InvoiceCalculator.php
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Muitas vezes, aquele &lt;code&gt;if&lt;/code&gt; estranho resolve um caso real de um cliente, e a mensagem de commit ou o ticket associado explicam o motivo. Remover sem entender é a forma mais rápida de reintroduzir um bug antigo.&lt;/p&gt;

&lt;h3&gt;Escreva testes de caracterização&lt;/h3&gt;

&lt;p&gt;Em código sem testes, o primeiro passo não é refatorar, é &lt;strong&gt;registrar o comportamento atual&lt;/strong&gt;. Testes de caracterização não verificam se o código está certo, verificam se ele continua fazendo o que já faz hoje:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;&amp;lt;?php

use PHPUnit\Framework\TestCase;

final class InvoiceCalculatorTest extends TestCase
{
    public function testKeepsCurrentBehaviorForLateInvoices(): void
    {
        $calculator = new InvoiceCalculator();

        // Valor obtido rodando o código atual, não calculado à mão
        $this-&amp;gt;assertSame(107.35, $calculator-&amp;gt;total(100.0, daysLate: 12));
    }
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Com alguns testes assim cobrindo o trecho que você vai mexer, a refatoração deixa de ser um salto no escuro. Se algum resultado mudar, você descobre na hora, e não pelo suporte.&lt;/p&gt;

&lt;h3&gt;Mude pouco de cada vez&lt;/h3&gt;

&lt;p&gt;Refatorações grandes em sistemas legados são arriscadas e difíceis de revisar. Mudanças pequenas, com commits separados para &quot;refatorar&quot; e &quot;alterar comportamento&quot;, são mais fáceis de entender, de revisar e, se preciso, de reverter.&lt;/p&gt;

&lt;p&gt;A regra do escoteiro ajuda aqui: sempre que passar por um trecho para fazer uma tarefa, deixe-o um pouco melhor do que encontrou. Um nome de variável mais claro, uma função extraída, um tipo adicionado. Ao longo de meses, isso muda o sistema sem nenhum grande projeto de reescrita.&lt;/p&gt;

&lt;h3&gt;Use análise estática com &lt;em&gt;baseline&lt;/em&gt;&lt;/h3&gt;

&lt;p&gt;Ferramentas como PHPStan e Psalm são valiosas em sistemas legados, mas a primeira execução costuma mostrar milhares de erros. O recurso de &lt;em&gt;baseline&lt;/em&gt; resolve isso: registra os erros existentes e faz a análise falhar apenas com erros &lt;strong&gt;novos&lt;/strong&gt;. O sistema para de piorar a partir daquele dia, e o código antigo vai sendo corrigido aos poucos.&lt;/p&gt;

&lt;h3&gt;Substitua por partes, não de uma vez&lt;/h3&gt;

&lt;p&gt;A tentação de reescrever tudo do zero é grande, e quase sempre é um erro: o sistema novo precisa reproduzir anos de regras de negócio que ninguém documentou, enquanto o antigo continua recebendo mudanças.&lt;/p&gt;

&lt;p&gt;Uma alternativa mais segura é o padrão &lt;em&gt;Strangler Fig&lt;/em&gt;: novas funcionalidades e módulos reescritos passam a viver em uma estrutura nova, enquanto o restante continua no código antigo. Aos poucos, a parte nova cresce e a antiga diminui, sem uma grande virada de chave.&lt;/p&gt;

&lt;h3&gt;Remova código morto com dados&lt;/h3&gt;

&lt;p&gt;Código morto aumenta o custo de manutenção e confunde quem lê. Mas, em sistemas antigos, &quot;parece que ninguém usa&quot; não basta. Logs, métricas de acesso e relatórios de cobertura de código em produção ajudam a confirmar que um trecho realmente não é executado antes de removê-lo.&lt;/p&gt;

&lt;p&gt;Software legado assusta — mas também ensina.&lt;/p&gt;

&lt;p&gt;Não estou romantizando ou glamorizando o legado.&lt;/p&gt;

&lt;p&gt;Mas essa é a realidade de boa parte do mercado, especialmente quando falamos de sistemas que já entregam valor, geram
receita e resolvem problemas reais todos os dias.&lt;/p&gt;

&lt;p&gt;💸 E mais: profissionais que dominam sistemas legados com visão de melhoria, estabilidade e entrega de valor costumam ser
bem reconhecidos — muitas vezes com &lt;strong&gt;ganhos acima da média do mercado.&lt;/strong&gt;&lt;/p&gt;
</content>
        </entry>
            <entry>
            <id>https://www.marcosmarcolin.com.br/blog/tenha-uma-carreira-a-longo-prazo</id>
            <link type="text/html" rel="alternate" href="https://www.marcosmarcolin.com.br/blog/tenha-uma-carreira-a-longo-prazo" />
            <title>Tenha uma carreira à longo prazo 💡💼</title>
            <published>2025-03-27T00:00:00+00:00</published>
            <updated>2025-03-27T00:00:00+00:00</updated>
            <author>
                <name>Marcos Marcolin</name>
            </author>
            <summary type="html">💡💼 Vivemos em uma era acelerada. A comparação é constante. Tudo parece imediato. E a promessa do “sucesso fácil” está por todos os lados.</summary>
            <content type="html">&lt;p&gt;No final do ano passado, completei 30 anos. E com o aniversário, veio aquela pergunta que costuma aparecer de tempos em tempos:
&quot;Será que estou no caminho certo?&quot;&lt;/p&gt;

&lt;p&gt;Olho ao redor e vejo muita gente no início da carreira já buscando cargos altos, salários altos e status. E quando isso não acontece rápido, a culpa recai no mercado, na faculdade, na empresa… em qualquer coisa externa.&lt;/p&gt;

&lt;p&gt;Vivemos em uma era acelerada. A comparação é constante. Tudo parece imediato. E a promessa do “sucesso fácil” está por todos os lados.&lt;/p&gt;

&lt;p&gt;Hoje, todo dia surge um novo CEO, CTO, Founder disso ou daquilo — como se esse fosse o único caminho possível.&lt;/p&gt;

&lt;p&gt;Mas deixa eu te dizer uma coisa: &lt;strong&gt;o sucesso é relativo.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;E não, não estou dizendo que você precisa passar a vida inteira na mesma empresa, por exemplo.&lt;/p&gt;

&lt;p&gt;Não era o que você esperava? Troque.
Quer trabalhar remoto e a empresa não oferece? Procure outra.
Não está se sentindo valorizado? Vá em busca de onde se sinta.
Você é livre para construir a sua jornada, do seu jeito.&lt;/p&gt;

&lt;p&gt;O que me preocupa é que muita gente está se guiando por atalhos, promessas vazias ou tentando copiar histórias de sucesso que não são suas.&lt;/p&gt;

&lt;p&gt;E nessa pressa toda, esquecem de olhar pra dentro, de entender o próprio tempo, o próprio ritmo.&lt;/p&gt;

&lt;p&gt;Eu, por exemplo, descobri que estou bem sendo funcionário. Tenho qualidade de vida, renda estável e saúde. Isso me basta — por agora.&lt;/p&gt;

&lt;p&gt;Empreender também pode ser incrível — só não é uma corrida que todo mundo precisa começar ao mesmo tempo. No meu caso, só significa respeitar meu tempo e minhas escolhas — sem atropelar minha trajetória tentando cumprir expectativas que nem são minhas.&lt;/p&gt;

&lt;p&gt;Talvez eu pareça conservador pra alguns. Mas quando olho pra minha trajetória, vejo uma construção sólida, com evolução constante.&lt;/p&gt;

&lt;p&gt;Tenho conquistado meu espaço aos poucos, no meu tempo — e isso me permite viver de um jeito que me faz bem.&lt;/p&gt;

&lt;p&gt;No fim, deixo uma pergunta simples, mas reflexiva:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Você está construindo uma carreira com propósito ou só correndo atrás de um sucesso que disseram que você deveria querer?&lt;/strong&gt;&lt;/p&gt;
</content>
        </entry>
            <entry>
            <id>https://www.marcosmarcolin.com.br/blog/novo-atributo-no-discard-php-8-5</id>
            <link type="text/html" rel="alternate" href="https://www.marcosmarcolin.com.br/blog/novo-atributo-no-discard-php-8-5" />
            <title>#[\NoDiscard] no PHP 8.5: marcando retornos importantes</title>
            <published>2025-03-05T00:00:00+00:00</published>
            <updated>2026-11-20T00:00:00+00:00</updated>
            <author>
                <name>Marcos Marcolin</name>
            </author>
            <summary type="html">Atributo #[\NoDiscard] no PHP 8.5: evite falhas silenciosas ao ignorar retornos importantes de funções e métodos.</summary>
            <content type="html">&lt;h2&gt;🐘💡 RFC: Atributo #[\NoDiscard] no PHP 8.5?!&lt;/h2&gt;

&lt;p&gt;Uma nova &lt;strong&gt;RFC em votação&lt;/strong&gt; no PHP 8.5 propõe a adição do atributo &lt;strong&gt;#[\NoDiscard]&lt;/strong&gt;, que alerta quando o retorno de uma função ou método não é utilizado.&lt;/p&gt;

&lt;h3&gt;⚠️ O problema?&lt;/h3&gt;

&lt;p&gt;Ignorar retornos pode gerar &lt;strong&gt;falhas silenciosas&lt;/strong&gt; e difíceis de detectar. Essa RFC busca tornar esse comportamento mais explícito e reduzir bugs, garantindo que retornos importantes sejam sempre verificados.&lt;/p&gt;

&lt;h3&gt;⚙️ Como funciona?&lt;/h3&gt;

&lt;p&gt;Se uma função for marcada com &lt;strong&gt;#[\NoDiscard]&lt;/strong&gt;, o PHP emitirá um &lt;strong&gt;warning&lt;/strong&gt; caso o retorno seja ignorado. Caso o desenvolvedor queira &lt;strong&gt;descartar intencionalmente&lt;/strong&gt; o retorno, será possível usar o &lt;strong&gt;(void) cast&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;A RFC ainda está em votação, mas tem boas chances de ser aprovada.&lt;/p&gt;

&lt;h3&gt;E aí, você gostaria desse recurso?&lt;/h3&gt;

&lt;p&gt;Eu particularmente, &lt;strong&gt;sim&lt;/strong&gt;, pois o uso é opcional. Tornar isso obrigatório seria uma loucura, que acredito nunca acontecer.&lt;/p&gt;

&lt;h2&gt;Exemplo prático&lt;/h2&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;&amp;lt;?php

#[\NoDiscard(&quot;Verifique o retorno para garantir o processamento correto.&quot;)]
function processarItens(array $items): array 
{
    $resultados = [];

    foreach ($items as $item) {
        $resultados[] = random_int(0, 1);
    }

    return $resultados;
}

$items = [&#039;foo&#039;, &#039;bar&#039;, &#039;baz&#039;];

// ⚠️ Warning: The return value of function processarItens() is expected to be consumed, Verifique o retorno para garantir o processamento correto in %s on line %d
processarItens($items);

// ✅ Sem warning, pois o retorno foi utilizado
$resultados = processarItens($items);

// ✅ Sem warning, pois o retorno foi intencionalmente descartado
(void) processarItens($items);
&lt;/code&gt;&lt;/pre&gt;

&lt;h2&gt;Atualização: aprovado no PHP 8.5&lt;/h2&gt;

&lt;p&gt;A RFC foi aprovada e o atributo &lt;code&gt;#[\NoDiscard]&lt;/code&gt; faz parte do PHP 8.5, lançado em 20 de novembro de 2025, junto com o cast &lt;code&gt;(void)&lt;/code&gt;. Ele aparece no meu resumo das &lt;a href=&quot;/blog/php-85&quot;&gt;novidades do PHP 8.5&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;Onde ele faz mais diferença&lt;/h2&gt;

&lt;p&gt;O exemplo acima é didático, mas o atributo brilha em situações onde ignorar o retorno é um erro fácil de cometer e difícil de perceber.&lt;/p&gt;

&lt;h3&gt;Objetos imutáveis&lt;/h3&gt;

&lt;p&gt;Esse é o caso clássico. Em um objeto imutável, métodos como &lt;code&gt;with...()&lt;/code&gt; não alteram o objeto atual, eles retornam uma &lt;strong&gt;nova instância&lt;/strong&gt;. Quem esquece disso escreve código que parece certo, mas não faz nada:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;&amp;lt;?php

final class Money
{
    public function __construct(
        public readonly int $amount,
        public readonly string $currency,
    ) {}

    #[\NoDiscard(&#039;Money é imutável, use o objeto retornado.&#039;)]
    public function add(int $amount): self
    {
        return new self($this-&amp;gt;amount + $amount, $this-&amp;gt;currency);
    }
}

$total = new Money(100, &#039;BRL&#039;);

// ⚠️ Warning: o resultado foi descartado e $total continua valendo 100
$total-&amp;gt;add(50);

// ✅ Correto
$total = $total-&amp;gt;add(50);
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;O mesmo erro acontece com frequência com &lt;code&gt;DateTimeImmutable::modify()&lt;/code&gt;, por exemplo. Com o atributo, o bug vira um aviso logo na primeira execução.&lt;/p&gt;

&lt;h3&gt;Funções que indicam sucesso ou falha pelo retorno&lt;/h3&gt;

&lt;p&gt;Funções que retornam &lt;code&gt;false&lt;/code&gt; quando algo dá errado, em vez de lançar uma exceção, são outro caso comum. Se o retorno é ignorado, a falha passa despercebida:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&quot;language-php&quot;&gt;&amp;lt;?php

#[\NoDiscard(&#039;Verifique se o lock foi obtido antes de continuar.&#039;)]
function acquireLock(string $name): bool
{
    // ...
}

if (!acquireLock(&#039;importacao&#039;)) {
    throw new RuntimeException(&#039;Importação já está em execução.&#039;);
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h3&gt;Resultados de operações&lt;/h3&gt;

&lt;p&gt;Métodos que retornam um objeto de resultado, com erros de validação ou o status de uma operação, também são bons candidatos. Ignorar esse objeto quase sempre significa ignorar um erro.&lt;/p&gt;

&lt;h2&gt;Detalhes do cast &lt;code&gt;(void)&lt;/code&gt;&lt;/h2&gt;

&lt;p&gt;O &lt;code&gt;(void)&lt;/code&gt; é a forma explícita de dizer &quot;eu sei que essa função retorna algo importante e estou descartando de propósito&quot;. Alguns pontos:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Ele só pode ser usado como instrução isolada. Não dá para usá-lo no meio de uma expressão, como em &lt;code&gt;$x = (void) foo();&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Ele pode ser usado em qualquer chamada, mesmo que a função não tenha o atributo. Nesse caso, não muda nada.&lt;/li&gt;
&lt;li&gt;Deixa a intenção documentada no próprio código: quem lê sabe que o descarte foi uma decisão, não um esquecimento.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;Compatibilidade com versões anteriores&lt;/h2&gt;

&lt;p&gt;Atributos são apenas metadados. Em versões anteriores ao PHP 8.5, uma função marcada com &lt;code&gt;#[\NoDiscard]&lt;/code&gt; continua funcionando normalmente: o atributo é ignorado e nenhum aviso é emitido. Isso permite que bibliotecas adicionem o atributo sem quebrar quem ainda está em versões mais antigas.&lt;/p&gt;

&lt;p&gt;O cast &lt;code&gt;(void)&lt;/code&gt;, por outro lado, é sintaxe nova. Usá-lo em código que ainda precisa rodar em PHP 8.4 ou anterior gera erro de sintaxe. Se esse for o seu caso, atribuir o retorno a uma variável não utilizada é a alternativa.&lt;/p&gt;

&lt;p&gt;Você pode ler mais sobre a proposta na publicação oficial: &lt;a href=&quot;https://wiki.php.net/rfc/marking_return_value_as_important?utm_source=blog&amp;amp;utm_medium=post&amp;amp;utm_campaign=blog-marcos-marcolin&amp;amp;utm_id=php85&quot;&gt;clique aqui&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;O que você achou dessa novidade? Compartilhe suas ideias nos comentários!&lt;/p&gt;
</content>
        </entry>
    </feed>
